OS/2 Shareware BBS: 35 Internet/35-Internet.zip/gz-311a.zip/gemz2fp.irc

Text File | 1999-03-21 | 284KB | 9,727 lines

^set preparse_aliases 1

@ gemz.ver = [3.11]
@ gemz.rel = [3.21]
@ gemz.patch = [1]
#@ beta = [YES]
^assign -beta
eval if (!gemzloaded) {
 @ logging = [OFF]
 @ publogging = [OFF]
 @ srand($time())
 eval load $exedir/gemzpos.sav
 eval if (!gzdefault.pos) {//window 1 show 1}
 /set client_stage 2
}{@ reloading = 1}

#************************************************************
# GemZ/2 For OpenChat/2 1.07 by gemini
#    email: [e-mail]
# There is no copyright, credit should be given where credit is
# due. If I was worried about copying, I wouldn't distribute.
# Note:  Thanks to those who have helped and given me ideas.
# Credits:  *mikh for the best irc client, for helping me out,
#            and for incredible userlist code.
#           *Everyone who has contributed ideas and was not
#            Stingy with their thoughts.
#************************************************************
^set input_prompt ░░░░░░░░░░░░░░░░░░░░0% (Initializing Script)
load mmpm.api
load file.api
load ctcpsnd.api
load botlist.api
load modeq.api
# Initialization
^set AUTO_WHOWAS OFF
^set BEEP_ON_MSG NONE
^set BEEP_TYPE 800 150
^set CNTLC_COLORS on
^set COPY_WITH_COLORS OFF
^set COPY_STRIP_CNTLCXX ON
^set COPY_TRANSLATE_USER_COLORS ON
^set CLOCK ON
^set DCC_BURST_MODE is ON
^set DCC_BLOCK_SIZE is 4096
^set DROP_DRAW_HINTS ON
^set DROP_USE_LINK ON
^set DROP_HINTS_COLOR 4 2
^set DRIVE_LETTERS ON
^set EPIC_PARSE_QUOTES ON
^set EPIC_PARSER ON
^set EXEC_PROTECTION OFF
^set FLOOD_CHECK_HOST ON
^set FLOOD_CHECK_USER ON
^set HIDE_PRIVATE_CHANNELS OFF
^set INDENT ON
^set INPUT_ALIASES OFF
^set JOIN_NEW_WINDOW OFF
^set LOGFILE_STRIP_COLORS ON
^set MODE_STRIPPER ON
^set NEW_TIMER_BEHAVOR ON
^set NICKLIST_SORT ON
^set NOVICE OFF
^set SHOW_AWAY_ONCE on
^set SHOW_NUMERICS_STR ~h■■■~0
^set STICKY_CN ON
^set TAB ON
^set TAB_MAX 100
#^set TRANSLATION LATIN_1
^set USERMODE -s+i
^set VERBOSE_CTCP OFF

@ _bkgd = [─]
@ OS2 = 1
##################################################################
# GemZ Custom Configuration settings                             #
# These are default and are changed by the setup menu and /save  #
##################################################################

#GemZ Path settings.
@ autojoinlist = [#os/2 #OpenChat]
@ gzsavefile =[$exedir/gemz.sav]
@ gemzsaveback =[$exedir/gemzsave.bak]
@ gzuserlist =[$exedir/gemzuser.sav]
@ gemzcolorfile = [$exedir/colors.gmz]
@ gemz.urlfile = [$exedir/gemzurl.htm]
@ MSGLOGFILE = [$exedir/messages.log]
@ actionsfile = [$exedir/script2/actplug.gmz]
@ gz.emailclient = []
@ gz.emaildir = []
@ gz.logdir = [$exedir/logs]

#these haven't chagned to gz.<var> yet.
@ defkickf = []
@ nck.buf = mid(0 3 $N)
@ imageviewer = [ib]
@ XDCCWinFont = [6x14]
@ gemz.long = [NO]
@ CTCPVERS = [ON]
@ NICKCOMPLETION = [ON]
@ USEMSGLOGFILE = [NO]
@ SHOWMSGTIME = [OFF]
@ SHOWPUBTIME = [OFF]
@ MSGBEEPS = [OFF]
@ ajoinfriends = [NO]
@ loadacts = [YES]
@ hourlytime = [ON]
@ autodccst = [ON]
@ re.connect = [ON]
@ ctcpsound = [ON]
@ ctcpsndreq = [ON]
@ autotalklogging = [OFF]
#GemZ Numerical values
@ gz.astime      = 30
@ gz.awaytime    = 15
@ gz.bantimeout  = 30
@ gz.dcctimeout  = 5
@ gz.delayoptime = 4
@ gz.igtimeout   = 3
@ gz.maxrelms    = 5
@ gz.maxwins     = 10

#GemZ toggles will move from being ON/OFF to 0/1 (Slow transition)
@ gz.longcsc = 1

@ gz.altstatus     = 0
@ gz.autorejoin    = 1
@ gz.ansi          = 1
@ gz.autochat      = 0
@ gz.autosave      = 0
@ gz.autotalk      = 0
@ gz.autotalkfg    = 0
@ gz.awaymsglog    = 1
@ gz.awaypublog    = 1
@ gz.beep          = 1
@ gz.confirm       = 1
@ gz.halfhour      = 0
@ gz.inputchan     = 1
@ gz.loadextras    = 1
@ gz.loghilites    = 0
@ gz.localoper     = 0
@ gz.mircsndpatch  = 0
@ gz.nicklist      = 1
@ gz.nicklock      = 0
@ gz.noctcpaway    = 0
@ gz.ovts          = 0
@ gz.notifyoper    = 1
@ gz.playifplaying = 1
@ gz.qaway         = 0
@ gz.qaaway        = 0
@ gz.sounds        = 1
@ gz.timestamps    = 1
@ gz.topictitle    = 0
@ gz.useclock      = 0
@ gz.usekfile      = 0

###########################
###CONVERT OLD VARIABLES###
###########################
alias update_vars {
 if (autorejoin) {@ gz.autorejoin = _bool($autorejoin);^assign -autorejoin}
 if (longcsc) {@ gz.longcsc = _bool($longcsc);^assign -longcsc}
 if (usekfile) {@ gz.usekfile = _bool($usekfile);^assign -usekfile}
 if (autotalkwin) {@ gz.autotalk = _bool($autotalkwin);^assign -autotalkwin}
 if (autochatwin) {@ gz.autochat = _bool($autochatwin);^assign -autochatwin}
 if (inputchan) {@ gz.inputchan = _bool($inputchan);^assign -inputchan}
 if (showtimestamps) {@ gz.timestamps = _bool($showtimestamps);^assign -showtimestamps}
 if (qaaway) {@ gz.qaaway = _bool($qaaway);^assign -qaaway}
 if (maxrelms) {@ gz.maxrelms = maxrelms;^assign -maxrelms}
 if (auto_away >= 0) {@ gz.awaytime = auto_away;^assign -auto_away}
 if (quietaways) {@ gz.qaway = _bool($quietaways);^assign -quietaways}
 if (altstatus) {@ gz.altstatus = _bool($altstatus);^assign -altstatus}
 if (autosave) {@ gz.autosave = _bool($autosave);^assign -autosave}
 if (autosavetime) {@ gz.astime = autosavetime;^assign autosavetime}
 if (gemzsounds) {@ gz.sounds = _bool($gemzsounds);^assign -gemzsounds}
 if (useclock) {@ gz.useclock = _bool($useclock);^assign -useclock}
 if (mircsndpatch) {@ gz.mircsndpatch = _bool($mircsndpatch);^assign -mircsndpatch}
 if (ov.timestamp) {@ gz.ovts = _bool($ov.timestamp);^assign -ov.timestamp}
 if (beep) {@ gz.beep = _bool($beep);^assign -beep}
 @ gz.localoper = _bool($gz.localoper)
 @ gz.nicklist = _bool($gz.nicklist)
 @ gz.loadextras = _bool($gz.loadextras)
 @ gz.nicklock = _bool($gz.nicklock)
 @ gz.awaymsglog = _bool($gz.awaymsglog)
 @ gz.awaypublog = _bool($gz.awaypublog)
 @ gz.halfhour = _bool($gz.halfhour)
 foreach gx stem {
  if (gx[$stem] == [ON]) {@ gx[$stem] = 1}
  else if (gx[$stem] == [OFF]) {@ gx[$stem] = 0}
 }
 ^assign -stem
}

#Sounds support
@ sounddir        = [$exedir/sounds]
@ snd.msg         = []
@ snd.dccgetfin   = []
@ snd.dccsendfin  = []
@ snd.sentdccreq  = []
@ snd.gotdccreq   = []
@ snd.pub         = []
@ snd.mekick      = []
@ snd.youkick     = [$sounddir/momo2.wav]
@ snd.kick        = [$sounddir/moo.wav]
@ snd.away        = []
@ snd.back        = []
@ snd.wkill       = []
@ snd.wopen       = []
@ snd.notify      = []
@ snd.notifyoff   = []
@ snd.chat        = []
@ snd.chatconnect = []
@ snd.sendconnect = []
@ snd.getconnect  = []
@ snd.hilitelist  = []
@ snd.newmail     = []
@ snd.join        = []


^set input_prompt ░░░░░░░░░░░░░░░░░░░░1% (Initializing Script)
#Status bar
^set color_status 70
^set color_status_b f7
^set color_status_d 88
^set draw_status_borders on
^set color_input 07
^set clock on
^eval ^set status_format <gz $gemz.ver> %H%@%N%*%# %A %Q%C%+ %Z %>%4%0
^set titlebar_format [%R]%c%Y[%s][%1]
#^eval ^set status_user <lag: 0>
^eval ^set status_user1 GemZ_$gemz.ver
^set status_clock [%T]
^set status_hold_lines [scroll: %B]
^set status_channel on %C
^set status_channel2 [on %c]
^set status_waiting_channel [Joining %J]
^set status_query Queried: %Q
^set status_away lurking
^set status_hold [---- Press enter to continue ----]
^set status_chanop @
^set status_notify  [─][%F]
^eval ^assign gemz.vers GemZ/2 v${gemz.ver} \(%${gemz.rel}#${gemz.patch}\)
^eval ^set client_information $gemz.vers
^set status_away lurking

^set color_user_0 07
^set color_user_1 02
^set color_user_2 06
^set color_user_3 0B
^set color_user_4 09
^set color_user_5 09
^set color_user_6 09
^set color_user_7 0B
^set color_user_8 0F
^set color_user_9 09
^set color_user_10 06
^set color_user_11 09
^set color_user_12 09
^set color_user_13 09
^set color_user_14 0E
^set color_user_15 0F
^set color_user_16 03
^set color_user_17 09
^set color_user_18 0F
^set color_user_19 0F
^set color_user_20 0B
^set color_user_21 0D
^set color_user_22 0D
^set color_user_23 0E
^set color_user_24 0B
^set color_user_25 0C
^set color_user_26 09
^set color_user_27 0C
^set color_user_28 07
^set color_user_29 09
^set color_user_30 07
^set color_user_31 0D
^set color_user_32 0B
^set color_user_33 03
^set color_user_34 0F
^set color_user_35 0F
^set color_user_36 0F
^set color_user_37 0A
^set color_user_38 08
^set color_user_39 04
^set color_user_40 09
^set color_user_41 0A
^set color_user_42 0B
^set color_user_43 08
^set color_user_44 0E
^set color_user_45 02
^set color_user_46 04
^set color_user_47 02
^set color_user_48 02
^set color_user_48 02
^set color_user_49 03
^set color_user_50 08
^set color_user_51 0B
^set color_user_52 05
^set color_user_53 0A
^set color_user_54 03
^set color_user_55 0F
^set color_user_56 09
^set color_user_57 0A
^set color_user_58 02
^set color_user_59 03
^set color_user_60 1F
^set color_user_61 0A
^set color_user_62 02
^set color_user_63 02
^set color_user_64 04
#65-74 are user reserved
^set color_user_75 8B
^set color_user_76 85
^set color_user_77 81
^set color_user_78 84
^set color_user_79 80
^set color_user_80 04
^set color_user_81 05
^set color_user_82 06
^set color_user_83 05
^set color_user_84 03
^set color_user_85 0B
^set color_user_86 0A


#0
@ cl = [~0]
@ gc.action = [~1]
@ gc.ctcp = [~2]
@ gc.ctcpban = [~3]
@ gc.ctcpnk = [~4]
@ gc.dcc = [~5]
@ gc.error = [~6]
@ gc.errortopic = [~7]
@ gc.inviteech = [~8]
@ gc.invitenk = [~9]
#10
@ gc.join = [~A]
@ gc.joinuh = [~B]
@ gc.kickc = [~C]
@ gc.kickn = [~D]
@ gc.kicked =  [~E]
@ gc.kill = [~F]
@ gc.killnk = [~G]
@ gc.mode = [~H]
@ gc.modenk = [~I]
@ gc.msg = [~J]
#20
@ gc.msguh = [~K]
@ gc.msgloginfo = [~L]
@ gc.msgbrac = [~M]
@ gc.nick = [~N]
@ gc.nickchg = [~O]
@ gc.notice = [~P]
@ gc.notify = [~Q]
@ gc.peren = [~R]
@ gc.pub = [~S]
@ gc.pubbrac = [~T]
#30
@ gc.pubmsg = [~U]
@ gc.sendout = [~V]
@ gc.section = [~W]
@ gc.sign = [~X]
@ gc.smsg = [~Y]
@ gc.split = [~Z]
@ gc.spub = [~a]
@ gc.topic = [~b]
@ gc.topicchan = [~c]
@ gc.wis = [~d]
#40
@ gc.wisinfo = [~e]
@ gc.wisname = [~f]
@ gc.nickpubmsg = [~g]
@ gc.gecho = [~h]
@ gc.help = [~i]
@ gc.modehack = [~j]
@ gc.outline = [~k]
@ gc.dccbar = [~l]
@ gc.time = [~m]
@ gc.nickaction = [~n]
#50
@ gc.glkind = [~o]
@ gc.gldata = [~p]
@ gc.glborder = [~q]
@ gc.gxnick = [~r]
@ gc.gxitem = [~s]
@ gc.gxdata = [~t]
@ gc.gxtitle = [~u]
@ gc.chops = [~v]
@ gc.lamers = [~w]
@ gc.cscborder = [~x]
#60
@ gc.msginfo = [~y]
@ gc.msgfrom = [~z]
@ gc.msgchan = [~!]
@ gc.host = [~@]
@ gc.bracket = [~#]
@ gc.user1 = [~\$]
@ gc.user2 = [~\%]
@ gc.user3 = [~\^]
@ gc.user4 = [~\&]
@ gc.user5 = [~\*]
#70
@ gc.user6 = [~\(]
@ gc.user7 = [~\)]
@ gc.user8 = [~\-]
@ gc.user9 = [~\+]
@ gc.user0 = [~\|]
@ gc.sjoin = [~$chr(128)]
@ gc.spart = [~$chr(129)]
@ gc.smode = [~$chr(130)]
@ gc.skick = [~$chr(131)]
@ gc.squit = [~$chr(132)]
#80
@ gc.hilitepubmsg = [~$chr(133)]
@ gc.swall = [~$chr(134)]
@ gc.swallmsg = [~$chr(135)]
@ gc.left = [~$chr(136)]
@ gc.opernick = [~$chr(137)]
@ gc.operuh = [~$chr(138)]
@ gc.ovserv = [~$chr(139)]


# CNTRL_C COLORS
assign blu 01
assign grn 02
assign cyn 03
assign red 04
assign mag 05
assign yel 06
assign wht 07
assign blk 08
assign bblu 09
assign bgrn 0A
assign bcyn 0B
assign bred 0C
assign bmag 0D
assign byel 0E
assign bwht 0F


# Echo Strings
^eval ^assign gemz ${gc.gecho}■■■${cl}
^assign gemz.act *
^assign gemz.str .gz.
^assign gemz.usage ***
^eval ^assign gemzov.str \\[\$bgrn\ov${cl}\\]\
alias gecho xecho -level crap $gemz $*
alias gbecho xecho -b -level crap $gemz $*
alias gtecho xecho -target $0 $gemz $1-
alias gtbecho xecho -b -target $0 $gemz $1-
alias gaecho xecho -level crap $gemz.act $*
alias gnecho xecho -level crap $*
alias guecho xecho -level crap $gemz.usage $*

# configurable strings (more to be added later).
@ str.away = [has set away!]
@ str.back = [has returned.]
@ str.autoaway = [auto away after idling]

# binds
bind  SELF_INSERT
#bind ^[ erase_line
bind ^_ self_insert
bind ^B self_insert
bind ^C self_insert
bind ^K parse_command //join -invite
bind ^R scroll_end
bind ^E scroll_backward
bind ^F parse_command wholeft
bind ^D scroll_forward
bind ^D parse_command ^pubreply
bind ^T parse_command ^togtitle
bind ^W parse_command ^setwall
bind ^V self_insert
bind ^X next_window
bind F1 parse_command /help
bind F2 parse_command if (C) {_nltog $C}{//^window nicklist off}
bind F3 parse_command if (gz.longcsc) {/csc}{/cnames}
bind F4 parse_command //^set nicklist_sort ${(nicklist_sort+1) % 3}
bind F5 parse_command /gl
bind F10 parse_command /clear
bind f11 parse_command _doclose
bind f12 parse_command _doget
bind alt-f12 parse_command _doresume

bind alt-1 parse_command //^window show 1
bind alt-2 parse_command //^window show 2
bind alt-3 parse_command //^window show 3
bind alt-4 parse_command //^window show 4
bind alt-5 parse_command //^window show 5
bind alt-6 parse_command //^window show 6
bind alt-7 parse_command //^window show 7
bind alt-8 parse_command //^window show 8
bind alt-9 parse_command //^window show 9
bind alt-a parse_command away
bind alt-b parse_command back -f
bind alt-c parse_command if (C) {chanmenu $C}{gecho No channel in current Window}
bind alt-l parse_command gz.showsubjects
bind alt-n next_window
bind alt-p previous_window
bind alt-t parse_command togtitle
bind alt-w parse_command windowlist command
bind Alt-F4 parse_command //window kill
bind Alt-F5 parse_command //window setwindowpos r 0 0 0 0
bind Alt-F9 parse_command //window setwindowpos m 0 0 0 0
bind Alt-F10 parse_command //window setwindowpos M 0 0 0 0
bind Shift-F1 parse_command /nick $gz.randnick()
bind Shift-F8 parse_command smartpaste
bind end end_of_line
bind Alt-End scroll_end

^set input_prompt ░░░░░░░░░░░░░░░░░░░░2% (General Aliases)
######################################################
# Aliases In (mostly) Alphabetical Order (hopefully) #
######################################################
alias .send quote PRIVMSG $0 :$cntl2mirc(f0 $1-)
alias .not quote NOTICE $0 :$cntl2mirc(f0 $1-)
alias _bool {@ function_return = [${match($0 ON YES 1 TRUE Y T) >= 1}]}

alias saysend {
 .send $0-
 fe ($unparse($0)) _s {
  xecho -target $_s ${gc.pubbrac}<${gc.spub}$N${gc.pubbrac}>${cl} $1-
 }
 ^assign -_s
}

#a#
alias addhilite {
 if ([$0]) {
  if ([$0]==[-n]) {
   push hilitelist $1
   gecho \$1\ added to the hilite list.
  }{
   if (match($0 $hilitelist)) {
    gecho a matching highlite string was found, to force
    gecho a new highlight, use /addhilite -n <string>
   }{
    push hilitelist $0
    gecho \$0\ added to the hilite list.
   }
  }
 }{
  gecho Usage: /addhilite <word/filter>
 }
}

alias addignore /ignore $*

alias addnotify {
 if ([$0]) {
  notify $0
 }{gecho Usage: /addnotify <nick1>}
}

alias addajoin {
 if ([$0]) {
  if (!match($0 $autojoinlist)) {
   gecho $0 Added to the Auto Join Channel list.  (/save to save settings)
   push autojoinlist $0
   makejoinmenu
  }{
   gecho $0 already in the Auto Join Channel list.
  }
 }{gecho Usage: /addajoin <Channel>}
}

alias addajoinkey {
 if ([$1]) {
  if (match($0 $autojoinlist)) {
   @ ajkeys[$%0] = [$1]
   gecho Key: $1 added for Autojoin channel $0
   makejoinmenu
  }{
   gecho $0 needs to be added to the autojoin list first
  }
 }{
  gecho Usage: /addajoinkey <#channel> <key>
 }
}

alias unajoinkey {
 if ([$0]) {
  if (ajkeys[$%0]) {
   ^assign -ajkeys.$%0
   gecho Key removed for $0
  }{
   gecho No Key set for $0
  }
 }{
  gecho Usage: /unajoinkey <#channel>
 }
}

alias initnotify {//^notify $0}

on ^msg "*GemZ/2 is keeping me anti*" #
on ^send_msg "*GemZ/2 is keeping me anti*" #
alias aioff {gecho Anit-Idle is now off!;^alias antiidle {}}
alias aion {
 gecho Anti-Idle Activated!
 gecho Anti-Idle will prevent you from idling on irc by sending
 gecho messages to the anti-idle channel..
 ^alias antiidle {
  msg $N GemZ/2 is keeping me anti-idle!
  gecho Server Anti-Idle Message sent.
  #join #!!!ANTI-IDLE!!!
  #wait -CMD *Anti-Idle* GemZ is keeping me anti-idle!
  ^timer 480 antiidle
 }
 /antiidle
}
alias addlchan {
 if ([$0] && ischannel($0)) {
  push lchanlist $0
  gecho \$0\ added to the leech channel list
 }{gecho usage /addlchan <#channel>}
}

alias unlchan {
 if ([$0]) {
  if (match($0 $lchanlist)) {
   @ lchanlist = stripw($0 $lchanlist)
   gecho \$0\ removed from the leech channel list
  }{gecho \$0\ not in the leech channel list}
 }{gecho Usage /unlchan <#channel>}
}

alias showhilite {
 if (hilitelist) {
  gecho HiliteList Words or filters.
 }{
  gecho Hilitelist is empty
 }
 fe ($hilitelist) _h.1 _h.2 _h.3 _h.4 {
  gecho $[15]_h.1 $[15]_h.2 $[15]_h.3 $[15]_h.4
 }
 if (hilitelist) {
  gecho End of list
 }
 purge _h
}


alias showlchan {
 gecho Leech Channel list:
 fe ($lchanlist) _l.1 _l.2 _l.3 _l.4 _l.5 {gecho $_l.1 $_l.2 $_l.3 $_l.4 $_l.5}
 purge _l
 gecho End of list
}

alias away {
 if (gz.awaymsglog) {setlog ON}
 if (gz.awaypublog) {setpublog ON}
 switch ($0) {
  (-c) {gz.subaway $*}
  (-q) {gz.subaway $*}
  (-n) {gz.subaway $*}
  (-p) {gz.subaway $*}
  (*) {
   if (gz.qaway) {gz.subaway -q $*}
   else {gz.subaway -n $*}
  }
 }
 ^hook gzaway
 gz.playsnd away
}

^set input_prompt ▒░░░░░░░░░░░░░░░░░░░5% (General Aliases)
#b#


alias back {
 setlog off
 setpublog off
 @ away = 0
 ^hook gzlog off
 if ([$0]==[-f]) {
  if (gz.qaway) {
   gecho Quietly Setting you back.
  }{
   mme $str.back $gemz.str
  }
 }{
  if ([$msglog_cnt++] >= [1]) {
   if ([$word(0 $"Play stored messages? (N/y)? ")]==[Y]) {readlog}
   if ([$word(0 $"Remove Message log? (Y/n)? ")]!=[N]) {remlog}
  }
  @ arg1 = [$0]
  switch ($arg1) {
   (-q) {gecho Quietly Setting you back.}
   (-c) {gecho Channel Setting you back.;if (arg1) {me $str.back \($1-\) $gemz.str}{me $str.back $gemz.str}}
   (*) {
    if (gz.qaway) {
     gecho Quietly Setting you back.
    }{
     if (arg1) {mme $str.back \($0-\) $gemz.str}{mme $str.back $gemz.str}
    }
   }
  }
  ^assign -arg1
  gecho ${gc.msgloginfo}Message Logging has been turned off${cl}
 }
 //away -all
 @ _waway = time() - awaytime
 ^hook gzback $tdiff($_waway)
 if (awaytime) {
  gecho You were away for $tdiff($_waway)
 }
 ^assign -_waway
 ^assign -awaytime
}

### on input kick reason or empty, returns unchanged kick reason if params
### not empty or generates a krad random one from gemz kickfile or from
### hardcoded ones...

alias _kick_reason {
 if ([$0] != []) {
  @function_return = [$0]
 }
 else if (gz.usekfile && file.exist($defkickf)) {
  @function_return = randread("$defkickf")
 }
 else {
  @ kick.msg = rand($numkick)
  @function_return = [$kick[$kick.msg] $gemz.str]
  ^assign -kick.msg
 }
}

# ------------- start of ripped LiCe /kk /k and /ban --------------------
#
# frog gave me persimission to rip this, probably he was drunk
# or something but who cares :)
#
# It is haxored a little to use internal cache instead of /userhost where
# possible
#

# $_cluster(n!u@h / u@h / h) changes the n!u@h pattern to a format
# suitable for bans, userlist, etc... (Author SrfRoG)
alias _cluster {
  @ _c_h = []
  @ _c_u = [*]
  if (index(! $0) != -1) {
    @ _c_t = mid(${index(! $0)+1} ${@0-index(! $0)+1} $0)
    @ _c_u = left($index(@ $_c_t) $_c_t)
    while (index($[1]_c_u -+~) > -1) {@ _c_u = mid(1 ${@_c_u - 1} $_c_u)}
    @ _c_h = mid(${index(@ $_c_t)+1} 80 $_c_t)
    ^assign -_c_t
  }{if (index(@ $0) != -1) {
    @ _c_u = left($index(@ $0) $0)
    while (index($[1]_c_u -+~) > -1) {@ _c_u = mid(1 ${@_c_u - 1} $_c_u)}
    @ _c_h = mid(${index(@ $0)+1} 80 $0)
  }{@ _c_h = [$0]}}
  while (@_c_u > 8) {@ _c_u = mid(1 10 $_c_u)}
  if (index($right(1 $_c_h) 0123456789) != -1)
    {@ function_return = [$_c_u@$mid(0 ${rindex(. $_c_h)+1} $_c_h)]##[*]}
    {if (index(. $_c_h) == rindex(. $_c_h))
    {@ function_return = [$_c_u@*$_c_h]}
    {@ function_return = [$_c_u@*$mid($index(. $_c_h) 80 $_c_h)]}
  }
  ^assign -_c_h
  ^assign -_c_u
}

# Multi-Purpose KICK command. (Orig. SrfRoG)

alias kk {
  if ([$P]==[@]) {
  if ([$[1]0]==[-]) {
    @ _k.o = mid(1 5 $0)
    @ _k.a = left($index(: $1-) $1-)
    @ _k.m = mid(${index(: $1-) + 1} 80 $1-)
  }{
    @ _k.a = left($index(: $0-) $0-)
    @ _k.m = mid(${index(: $0-) + 1} 80 $0-)
  }
  if ([$_k.m]==[]) {@ _k.m = _kick_reason()}{
    if (index( $_k.m) >= 0) @_k.m = cntl2mirc(f0 $_k.m)
  }
  modeq.init
  for (@ _k.c = 0, word($_k.c $_k.a), @ _k.c = _k.c + 1) {
    @ _k.t = word($_k.c $_k.a)
    switch ($_k.t) {
    (*!*@*) {}
    (*@*) {
        if (left(1 $_k.t) == [*]) @ _k.t = [*!$_k.t]
        else @ _k.t = [*!*$_k.t]
    }
    (*) {
        @ _k.t = [$_k.t!*@*]
    }
    }
    fe ($chanusers($C 3 $_k.t)) xx {
      if (ischanop($N $C) && (xx!=N || !_k.o)) {
        @ _k.u = nickdata($C $xx)
        fec ($_k.o) o {
      switch ($o) {
            (b) {modeq.addban $C *!*$_cluster($_k.u)}
            (c) {modeq.addban $C *!*@*$mid($rindex(. $_k.u) 4 $_k.u)}
            (h) {modeq.addban $C *!$_cluster($_justhost($_k.u))}
            (u) {modeq.addban $C *!*$left($index(@ $_k.u) $_k.u)@*}
      }
        }
        if (ischanop($XX $C) && index(bchu $_k.o) >= 0) modeq.add_mode -o $xx
        if (onchannel($XX $C)) {modeq.add_kick $XX $_k.m}
      }
    }
    ^assign -XX
  }
  modeq.apply_modes $C
  purge _k
  }{echo $SHOW_NUMERICS_STR\You are not channel operator on $C\.}
}

alias k {
 if ([$[1]0]==[-])
 {if ([$2]) {kk $0 $1 :$2-}{kk $0 $1 :$_kick_reason()}}
 {if ([$1]) {kk $0 :$1-}{kk $0 :$_kick_reason()}}
}
alias kb if ([$1]) {kk -b $0 :$1-}{kk -b $0 :$_kick_reason()}
alias ks if ([$1]) {kk -hu $0 :$1-}{kk -hu $0 :$_kick_reason()}

$0 == channel, $1 == userhost, $2 == nick, $3 == type
alias _do_ban if (ischanop($N $0)) {
    modeq.init
    if ([$3]) {
        switch ($3) {
                (c) {modeq.addban $0 *!*@*$mid($rindex(. $1) 4 $1)}
                (h) {modeq.addban $0 *!$_cluster($_justhost($1))}
                (u) {modeq.addban $0 *!*$left($index(@ $1) $1)@*}
        }
    }{
        modeq.addban $0 *!*$_cluster($1)
    }
        if (ischanop($2 $0)) {modeq.add_mode -o $2}
    modeq.apply_modes $0
}

$0 == channel, $1 == userhost, $2 == nick, $3 == type
alias _do_ban if (ischanop($N $0)) {
    modeq.init
    if ([$3]) {
        switch ($3) {
                (c) {modeq.addban $0 *!*@*$mid($rindex(. $1) 4 $1)}
                (h) {modeq.addban $0 *!$_cluster($_justhost($1))}
                (u) {modeq.addban $0 *!*$left($index(@ $1) $1)@*}
        }
    }{
        modeq.addban $0 *!*$_cluster($1)
    }
        if (ischanop($2 $0)) {modeq.add_mode -o $2}
    modeq.apply_modes $0
}

# User Ban/RBan functions. (Orig. by SrfRoG)
alias ban {
  if ([$P]==[@]) {
    if ([$0]) {
      ^assign opt $1
      if (!rmatch($0 *!* *@* *.*)) {
        @ t.found = 0
    fe ($mychannels()) t.ch {
            if (onchannel($0 $t.ch)) {
            @ t.found = t.ch
            break
        }
    }
    if (t.found && (t.u = nickdata($t.found $0)) != [<UNKNOWN>]) {
        _do_ban $C $t.u $0 $1
    }{
            userhost $0 -cmd _ban_uh $$* $C $1
      }
      }{
    modeq.init
    fe ($0-) ban.host {
        if (index(@ $ban.host) == -1) {
            @ban.host = [$[1]ban.host]==[*]?[*!*@$ban.host]:[*!*@*$ban.host]
        }{
            if (index(! $ban.host) == -1) {
                @ban.host = [$[1]ban.host]==[*]?[*!$ban.host]:[*!*$ban.host]
            }
        }
        modeq.addban $C $ban.host
    }
    modeq.apply_modes $C
      }
    }{echo Usage: /BAN <nick> [type]}
  }{echo $SHOW_NUMERICS_STR\You are not channel operator in $C\.}
  purge t
}

alias _ban_uh if ([$4]!=[<UNKNOWN>]) {
    _do_ban $5 $3@$4 $0 $6
}{
    echo $SHOW_NUMERICS_STR$0: No such nick
}

alias banstat {
 if ([$0]) {
  if (match($0 $mychannels())) {
   if (chanmode($0 1)) {
    mode $0 +b
   }{gecho There are no Bans in $0}
  }{
   gecho You are not in $0
  }
 }{if (C) {banstat $C}{gecho You are not in a channel}}
}

alias beep {if (match($0 ON OFF)) {^set beep $toupper($0);@ gz.beep = _bool($0)};gecho Beep is now set to ${gz.beep ? [ON] : [OFF]}}
alias bk {if ([$0]) {k -b $0 $1-}{gecho Usage /bk <nick> [<reason>]}}
alias bki kbi $*
alias kbi {if ([$0]) {/k -b $0 $1-;ig $0 ALL}{gecho Usage /kbi <nick> [<reason>]}}
alias bkip kbip $*
alias kbip {if ([$0]) {/k -b $0 $1-;ig $0 -d ALL}{gecho Usage /kbip <nick> [<reason>]}}
alias bye si $*
#c#

alias cgset {cset $0;cset $0 $"Enter new Value (Enter=NoChange) : "}

alias c {mode $C $*}
alias clearsc {//clear -scrollback}

alias _chan {
# quick and dirty little function to return a channel name from a string...
# this will _only_ return names of channels you are currently in!
# -- asmodean <[e-mail]>
  for (@ __i = 0, word($__i $mychannels()), @ __i = __i + 1) {
    @ __t[$struct($word($__i $mychannels()))] = 1
  }
 ^assign -__i
  @ __j = struct($mid($index(&# $*) 256 $*))
  fec ($__j) __a __b {
    @ __k = __k ## __a ## __b
    if (__t[$__k]) {@ function_return = decode($__k)}
  }
 ^assign -__j;^assign -__k;^assign -__a;^assign -__b
  purge __t
}

alias caway {away -c $*}
alias cback {back -c $*}

alias chanppl {
 if (C) {
  @ _ppl.oper = 0
  @ _ppl.ops = 0
  @ _ppl.total = 0
  @ _ppl.voice = 0
  ^on ^raw_irc "% 352 *" {
   @ _ppl.total++
   if (index(@ $8) >= 0) {@ _ppl.ops++}
   if (index(* $8) >= 0) {@ _ppl.oper++}
   if (index(+ $8) >= 0) {@ _ppl.voice++}
   if (!_ppl.placer) {gtecho $3 Detailed List for $C\}
   @ _ppl.placer = 1
   gtecho $3 [$[4]8] $gz.finline(65 $7\!$gz.finuh($4 $5)\ $6)
  }
  ^on ^raw_irc "% 315 *" {
   gtecho $3 End of List for $3\... Opers: $_ppl.oper\ Ops: $_ppl.ops\ voice: $_ppl.voice\ Total: $_ppl.total\
   purge _ppl
   ^on ^raw_irc -"% 315 *"
   ^on ^raw_irc -"% 352 *"
  }
 //quote WHO $C
 }{
  gecho You are not on a channel
 }
}

alias chat {
 if (gz.chatwinstat($0) == 0) {
  /talk \=$0 $1
  ^on ^window_kill "=$0_Queried" {
   nochat $0
   //window refnum \=$0_Queried kill
   ^on ^window_kill -"$0"
  }
 }
 switch ($gz.chatstat($0)) {
  (0) {//window show =$0_Queried;//dcc chat $0}
  (1) {//window show =$0_Queried;gecho Waiting for party to respond...}
  (2) {//window show =$0_Queried}
  (3) {//window show =$0_Queried;//dcc chat $0}
 }
}

alias clearnotifylist {}
alias clist {
#ripped from KMP fixed the mispelling in "colour" :P
  gbecho 08╒══════════════════════════════════════════════════════════════════════╕
  gbecho 08│ [0FOS308] 07ircII color list for momos.  0FUsage08:07 01^C09XY 07where 09X07 is the back- 08 │
  gbecho 08│ 07ground color, 09Y07 the foreground.    0Fie08: 07^C49 is 49 Bright Blue on Red 08  │
  gbecho 08╞═══╤═════════╤═══╤════════════════╦╦═══╤═════════╤═══╤════════════════╡
  gbecho 08│08 0 08│08 Black   08│80 8 08│80 Bright Black   08║║08 0 08│00 Black   08│08 8 08│08 Bright Black   08│
  gbecho 08│19 1 08│19 Blue    08│91 9 08│91 Bright Blue    08║║01 1 08│01 Blue    08│09 9 08│09 Bright Blue    08│
  gbecho 08│2A 2 08│2A Green   08│A2 A 08│A2 Bright Green   08║║02 2 08│02 Green   08│0A A 08│0A Bright Green   08│
  gbecho 08│3B 3 08│3B Cyan    08│B3 B 08│B3 Bright Cyan    08║║03 3 08│03 Cyan    08│0B B 08│0B Bright Cyan    08│
  gbecho 08│4C 4 08│4C Red     08│C4 C 08│C4 Bright Red     08║║04 4 08│04 Red     08│0C C 08│0C Bright Red     08│
  gbecho 08│5D 5 08│5D Magenta 08│D5 D 08│D5 Bright Magenta 08║║05 5 08│05 Magenta 08│0D D 08│0D Bright Magenta 08│
  gbecho 08│6E 6 08│6E Yellow  08│E6 E 08│E6 Bright Yellow  08║║06 6 08│06 Yellow  08│0E E 08│0E Bright Yellow  08│
  gbecho 08│7F 7 08│7F White   08│F7 F 08│F7 Bright White   08║║07 7 08│07 White   08│0F F 08│0F Bright White   08│
  gbecho 08╘═══╧═════════╧═══╧════════════════╩╩═══╧═════════╧═══╧════════════════╛
}
#cached /names
alias cnames {
 if ([$0]) {
  if (ischannel($0)) {
   if (onchannel($N $0)) {
    gtecho $0 $0: $_cnames($0)
   }{gecho You are not on $0}
  }{gecho $0 is not a valid channel;gecho Usage: /cnames [<#channel>]}
 }{
  if (C) {
   gecho $C: $_cnames($C)
  }{gecho You are not on any channels}
 }
}

alias _cnames {
 fe ($chanusers($0)) _cn.ch {
  if (ischanop($_cn.ch $0)) {
   @ _cn.no #= [ @$_cn.ch]
  }{
   @ _cn.nv #= isvoice($_cn.ch $0) ? [ +$_cn.ch] : [ $_cn.ch]
  }
 }
 @ function_return = [${gc.chops}$_cn.no${cl}${gc.lamers}$_cn.nv$_cn.nl${cl}]
 purge _cn
}


alias creseti {/c -inst+mlk 40 resetting;/c +inst-mlk resetting}
alias creset {/c -nst+milk 40 resetting;/c +nst-milk resetting}
alias ctcpreply if ([$0]) {gecho ${gc.ctcpban}ctcp${cl}: ${gc.ctcp}$tolower($1) reply${cl} from ${gc.ctcpnk}$0${cl}: $2-}
alias ctcpreq if ([$0]) {gecho ${gc.ctcpban}ctcp${cl}: ${gc.ctcp}$tolower($2) request${cl} from ${gc.ctcpnk}$0${cl} ${gc.peren}\(${gc.ctcpnk}$userhost()${gc.peren}\)${cl} to ${gc.ctcpnk}$1${cl}}
alias cwait {wait -CMD #;wait -CMD $0-}
# Cycle written by mikh
alias cycle {
 if ([$0]) {
  if (onchannel($N $0)) {
   @ _gk.t = key($0)
   //leave $0
   ^hook gzcycle $0
   if (chanwindow($0)) {
    wait -cmd //window $chanwindow($0) channel $0
    if (_gk.t) {//quote JOIN $0 $_gk.t}
   }{
    wait -cmd //quote JOIN $0 $_gk.t
   }
  }{
   gecho ${gc.errortopic}You are not on channel $0 ${cl}
  }
  ^purge _gk
 }{
  if (C) {
   cycle $C
  }{
   gecho ${gc.errortopic}You are not on any channel in this window${cl}
  }
 }
}
#csc written by mikh, enhanced by gemini
alias csc {
 if ([$0] && onchannel($N $0)) {
  @ _co.t = #chanusers($C)_co.u
  fe ($gz.chanops($0)) _co.tn {@ _co.co #= _co.co ? [ @$_co.tn] : [@$_co.tn]}
  fe ($gz.voices($0)) _co.tn {@ _co.v #= _co.v ? [ +$_co.tn] : [+$_co.tn]}
  @ _co.l = gz.lamers($0)
  gtbecho $0 ${gc.cscborder}┌───────────┬──────────────┬─────────────┬─────────────┬────────────┐
  gtbecho $0 ${gc.cscborder}│${gc.topicchan}$[10]0${cl} ${gc.cscborder}│${cl} ${gc.chops}ChanOps${cl}: \$[-3]#_co.co\ ${gc.cscborder}│${cl} ${gc.lamers}Voiced${cl}: \$[-3]#_co.v\ ${gc.cscborder}│${cl} ${gc.lamers}Normal${cl}: \$[-3]#_co.l\ ${gc.cscborder}│${cl} Total: \$[-3]_co.t\ ${gc.cscborder}│
  gtbecho $0 ${gc.cscborder}├───────────┴──────────────┴─────────────┴─────────────┴────────────┤
  if (_co.co) {
  fe ($_co.co) _co.1 _co.2 _co.3 _co.4 _co.5 _co.6 {
   gtbecho $0 ${gc.cscborder}│ ${gc.chops}$[10]_co.1 $[10]_co.2 $[10]_co.3 $[10]_co.4 $[10]_co.5 $[10]_co.6 ${gc.cscborder}│
  }
  }
  if (_co.v || _co.l) {
  fe ($_co.v $_co.l) _co.1 _co.2 _co.3 _co.4 _co.5 _co.6 {
   gtbecho $0 ${gc.cscborder}│ ${gc.lamers}$[10]_co.1 $[10]_co.2 $[10]_co.3 $[10]_co.4 $[10]_co.5 $[10]_co.6 ${gc.cscborder}│
  }
  }
  gtbecho $0 ${gc.cscborder}└───────────────────────────────────────────────────────────────────┘
  purge _co
 }{
  if ([$0]) {
   gecho You are not on channel $0
  }{
   if (C) {
    csc $C
   }{
    gecho No current channel in this window
   }
  }
 }
 purge _co
}

#d#
alias du {gecho Are you sure you wanna do this?}
alias dump du
alias dialogplay {
 filedialog OA $sounddir/*.wav "Play Sound files" "Play/Exit" "Play" {
  if ([$0]==[OK]) {play "$decode($1)"}
  else if ([$0]==[APPLY]) {play "$decode($1)"}
 }
}

alias dialogcload {filedialog O $exedir/script2/*.gzc "Load Color File" "Load" {if ([$0]==[OK]) {load $decode($1-)}}}
alias dialogsavec {filedialog S $exedir/script2/*.gzc "Save Color File" "Save" {if ([$0]==[OK]) {savec $decode($1-)}}}
alias dialpizza {/nick PizzaBoy;//signoff delivering pizza to the momos}
alias senddialog {//filedialog OM $gx.uploaddir\* "Select Files to send" sendproc send $0 $$*}
alias resenddialog {//filedialog OM $gx.uploaddir\* "Select Files to send" sendproc resend $0 $$*}

alias sendproc {
 if ([$2] == [OK]) {
  @ _sp.f = 0
  fe ($3-) _sp.t {
   if (fexist("$decode($_sp.t)") == 1) {
    //dcc $0 $1 "$decode($_sp.t)"
    @ _sp.f = 1
   }
  }
  if (_sp.f) {gecho File Request sent to $1}
  purge _sp
 }
}

alias mansenddialog {//filedialog OM $gx.uploaddir\* "Select Files to send" mansendproc send $$*}
alias manresenddialog {//filedialog OM $gx.uploaddir\* "Select Files to send" mansendproc resend $$*}

alias mansendproc {
 if ([$1] == [OK]) {
  @ _sp.n = [$"[gxDCC] Nick to send to : "]
  if (_sp.n) {
   @ _sp.f = 0
   fe ($2-) _sp.t {
    if (fexist($decode($_sp.t)) == 1) {
     //dcc $0 $_sp.n $decode($_sp.t)
     @ _sp.f = 1
    }
   }
  }
  if (_sp.f) {gecho File Request sent to $_sp.n}
  purge _sp
 }
}

alias xdccwin {
 if (xdccwinon) {
  window refnum XDCC kill
  @ xdccwinon = 0
 }{
  ^on ^window_kill XDCC {
  @ xdccwinon = 0
 }
 @ _xdccwin = [XDCC]
 if (ch.winsizepos[$%_xdccwin]) {
  @ newwindow(1 1 $word(0 $ch.winsizepos[$%_xdccwin]) menubar XDCC $ref(2-5 $ch.winsizepos[$%_xdccwin]))
  ^window name XDCC level DCC
 }{
  window new level DCC
  window name XDCC
 }
 ^assign -_xdccwin
 @ xdccwinon = 1
 }
}

#Input <number of bites sent> <time (in irc format) tranfer started>
#Returns raw number of bytes per second (number only)

alias dcc_averate {@ function_return = time() - [$1] ? (([$0] / ([${time() - [$1]})) * 100) / 1024 : 0}

#<Total Bytes Sent>, <Total Size of File>, <Time Xfer Started, [<possible Offset>]
alias dcc_eta {
 ^set floating on
 if (![$0] || ![$2]) {@ function_return = [N/A]}{
 @ _eta.xfer = [$0]
 @ _eta.tot = [$1]
 @ _eta.rate = [$2]
 @ _eta.left = _eta.tot - _eta.xfer
 @ _eta.left = (_eta.left * 100 ) / 1024
 ^set floating off
 @ _eta.secs = _eta.left / _eta.rate
 @ function_return = _eta.secs
 purge _eta
 }
}

alias dcc.averate {
#Input <number of bites sent> <time (in irc format) tranfer started>
#Returns raw number of bytes per second (number only)
 @ function_return = time() - [$1] ? (([$0] / ([${time() - [$1]})) * 100) / 1024 : 0
}

alias dcc.eta {
#<Total Bytes Sent>, <Total Size of File>, <Time Xfer Started, [<possible Offset>]
#returns: total estimated number of seconds
 ^set floating on
 if (![$0] || ![$2]) {@ function_return = [N/A]}{
 @ _eta.left = [$1] - [$0]
 @ _eta.left = (_eta.left * 100 ) / 1024
 ^set floating off
 @ _eta.secs = _eta.left / [$2]
 @ function_return = _eta.secs
 purge _eta
 }
}

alias dcc.perc {
#$0 = actual percentage
#ex: 34.67432
 @ _dx.FULL  = [▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒]
 @ _dx.EMPTY = [░░░░░░░░░░░░░░░░░░░░]
 @ function_return = mid(0 ${[$0] / 5} $_dx.full) ## mid(0 ${20 - ([$0] / 5)} $_dx.empty) ## [\($[4]0\%\)]
 purge _dx
}


alias dcc_percentage {
#input, two number, in which percentage will be computed
#ex: 1234 123456
 ^set float on
 @ _dp.per = [${[$0] * 100}] / [$1]
 ^set float off
 @ function_return = dcc.perc($_dp.per)
 purge _dp
}



alias deban unban
alias disco {say You know what I wanna do now?;WAIT;/me puts on $gender leisure suit and does $gender best Travolta impression...;say STRUT!!!!!!!!!!!!!}
#e#
#f#
alias find {
 if ([$0]) {
  if (C) {
   if (onchannel($0 $C)) {
    if (ischanop($0 $C)) {@ _fm.op = [@]}{@ _fm.op = [ ]}
    gecho Found: $_fm.op${gc.nick}$[15]0${cl} ${gc.bracket}\[${gc.host}$uh($0)${gc.bracket}\]${cl}
   }{
    gecho Finding all users who match filter: \$0\
    @ _fm.a = bmatches($0 $chanusers($C 2))
    fe ($_fm.a) _fm.m {
     @ _fm.m--;
     if (ischanop($word($_fm.m $chanusers($C 0)) $C)) {@ _fm.op = [@]}
     else if (isvoice($word($_fm.m $chanusers($C 0)) $C)) {@ _fm.op = [+]}
     else {@ _fm.op = [ ]}
     gecho matched: $_fm.op${gc.nick}$[15]word($_fm.m $chanusers($c 0))${cl} ${gc.bracket}\[${gc.host}$word($_fm.m $chanusers($c 1))${gc.bracket}\]${cl}
    }
    if (#_fm.a) {
     gecho Found $#_fm.a Matches
    }{
     gecho No matches found
    }
    purge _fm
   }
  }{gecho No channel in this window}
 }{gecho Usage: /find <filter>}
}

alias finger if ([$0]) {ctcp $0 FINGER}{ctcp $C FINGER}
alias fing finger $*
alias f finger $*

alias subfixnick {
 @ _sbf.n = [$"New nick to lock: "]
 if (_sbf.n) {
  /fixnick $_sbf.n
  ^assign -_sbf.n
 }
}

alias fixnick {
 if ([$0]) {
  if ([$0]==[off]) {
   if (!match($notify())) {
    //^notify \-$fixed_nick
   }
   gecho Fixed Nick feature turned off
   @ gz.nicklock = 0
  }{
   gecho Locking Nick at $0
   @ fixed_nick = [$0]
   //^notify +$0
   @ gz.nicklock = 1
  }
  }{
   if (fixed_nick) {
    gecho Your Nick is fixed:  $fixed_nick
   }{
    gecho You do not have a Fixed Nick
  }
  gecho Usage /fixnick <nick> || [off]
  gecho Nick will be recovered when the momo who has stolen it has signed off.
 }
 @ menucontrol(&setup &200 check $gz.nicklock)
 @ menucontrol(&setup &201 text Fixed Nick:    [$fixed_nick])
}

alias fixnick {
 if (match($0 $gz.servergroups())) {
  if ([$1]) {
   @ fn[$0][nick] = [$1]
   gecho Fixed Nick for $0 is now $fn[$0][nick]
  }{
   @ _sn = [$"Fixed Nick for This server: "]
   if (_sn) {
    @ fn[$0][nick] = _sn
    gecho Fixed Nick for $0 is now $fn[$0][nick]
   }
  }
 }{gecho Usage: /fixnick <Servergroup> [<nick>]}
 purge _sn
 fixnickmenu
}


alias gz.checkfixnick {
 fe ($myservers(1)) _ms.s {
  @ _ms.g = fn[$servergroup($_ms.s)]
  if (fn[$servergroup($_ms.s)]) {
   if (fn[$servergroup($_ms.s)][nick] != N) {
    evalserver $_ms.s {
     userhost $fn[$servergroup($_ms.s)][nick] -CMD if ([$3]==[<UNKNOWN>]) {
      gecho Reclaiming nick... $0
      /nick $0
}}}}}}


^on #-channel_signoff 33 "*" {gz.takefixednick $lastserver() $1}
^on #-nickname 33 "*" {
    if ([$1] != N) {
        gz.takefixednick $lastserver() $0
    }
}
alias gz.takefixednick {
    if (fn[$servergroup($0)]) {
        if (fn[$servergroup($0)][nick] == [$1]) {
        if (fn[$servergroup($0)][nick] != N) {
              gecho Reclaiming nick ... $fn[$servergroup($0)][nick]
              evalserver $0 nick $fn[$servergroup($0)][nick]
          }
    }
    }
}


##Had to hook this cuz serialized notify_signoffs were not working as of 1.06g
on #-hook 25 "gzsignoff *" {
 if (fn[$servergroup($lastserver())]) {
  if ([$1] == fn[$servergroup($lastserver())][nick]) {
   gecho Reclaiming Nick on $servergroup($lastserver()) \($fn[$servergroup($lastserver())][nick]\)
   //nick $fn[$servergroup($lastserver())][nick]
  }
 }
}


alias fixtime @ function_return = mid(11 8 $stime($0))
alias fixdate @ function_return = mid(4 12 $stime($0))
#wanted to write my own fix.send, even if srfrogs was good enough.
alias gz.fixsend {
    fe ($*) _fs.w {@ _fs.r #= _fs.r ? [,] ## _fs.w : _fs.w}
    @ function_return = _fs.r
  purge _fs
}


alias fix.size {
 ^set float on
 if ([$0] <= 1023) {@ function_return = [] ## [$0] ## [] ## [ bytes]}
 else if ([$0] <= 1048575 ) {
  @ _fs.2 = [$0] / 1024
  @ function_return = []## mid(0 $index(. $_fs.2) $_fs.2) ## left(2 $mid($index(. $_fs.2) $@_fs.2 $_fs.2)) ## [] ## [ k]
  ^assign -_fs.2
 }
 else {
  @ _fs.2 = [$0] / 1048576
  @ function_return = []## mid(0 $index(. $_fs.2) $_fs.2) ## left(3 $mid($index(. $_fs.2) $@_fs.2 $_fs.2)) ## [] ## [ MB]
  ^assign -_fs.2
 }
 ^set float off
}


alias fix.ip @ function_return = (1 + index($right(1 $0) 0123456789))
alias fixhost {if (index(. $0)==rindex(. $0)) {@ function_return= [$1] ## [$0]}{@ function_return= [$0]}}
alias fixname {if (rmatch($0 ?? ?)) {@ function_return= [$1]}{@ function_return= [$1] ## mid(1 99 $0)}}
alias fixdomain {if (index(. $0)!=rindex(. $0)) {if (is_ip($0)) {@ unction_return= left($rindex(. $0) $0) ## [.$1]}{@ function_return= [$1$mid($index(. $0) 99 $0)]}}{@ function_return= [$1$0]}}
alias fix.eta {
 @ _et.min = ([$0] / 60) - (([$0] / 3600) * 60)
 @ _et.sec = [$0] % 60
 if (@_et.sec==1) {@ _et.sec = [0$_et.sec]}
 if (@_et.min==1) {@ _et.min = [0$_et.min]}
 @ function_return = [${[$0] / 3600}:$_et.min:$_et.sec]
 purge _et
}

alias fix.umask {
 if (fix.ip($1)) {
  @ function_return = [$strip(~ $0)@$left(${rindex(. $1)+1} $1) ## [*]]
 }{
  if (index(. $1) != rindex(. $1)) {
   @ function_return = [$strip(~ $0)@*$mid($index(. $1) 80 $1)]
  }{
   @ function_return = [$strip(~ $0)@$1]
  }
 }
}

alias fk if (C) {
 if ([$0]) {
  @ _fk.c = C
  fe ($chanusers($_fk.c 2)) _fk.uh {
   if (match($0 $_fk.uh)) {//kick $_fk.c $left($index(! $_fk.uh) $_fk.uh) <Filter Kick: \$0\>}
  }
  purge _fk
 }{gecho Usage: /fk <filter>}
}
alias frelm {
 if ([$1]) {
  say *$0* $1-
 }{gecho Usage: /frelm <fromnick> msg}
}

alias furl if ([$0]) {
  if (searchpath(bookmark.htm $PATH)) {
   exec -name furl furl.exe $searchpath(bookmark.htm $PATH) $0-
  }{gecho could not find bookmark.htm in path}
}{gecho usage: /furl <search string>}

on ^exec "furl *" {gecho $2-}


#g#
#Queue functions
#Queue will automatically pop itself, to add use csq.aqueue <servernum> <command>
@ csq.maxpos = 1000

alias csq.pqueue {
 if (csq[curpos]==[]) {@ csq.curpos = 1}
 if (csq[$csq[curpos]][s] != []) {
  evalserver $csq[$csq[curpos]][s] $csq[$csq[curpos]][c]
  ^assign -csq.$csq[curpos].s
  ^assign -csq.$csq[curpos].c
  if (csq[curpos] == csq[maxpos]) {@ csq.curpos = 1}{@ csq.curpos++}
 }
}

alias csq.aqueue {
 if (csq[curend] == csq[maxpos]) {@ csq.curend = 1}{@ csq.curend++}
 @ csq[$csq.curend][s] = [$0]
 @ csq[$csq.curend][c] = [$1-]
}

alias csq.squeue {
 for (@ idx = 1, idx <= csq.maxpos, @ idx++) {
  if (csq[$idx][s] != []) {gecho Server: $csq[$idx][s] Command: $csq[$idx][c]}
 }
}

alias repeat {for (@ idx = 1, idx <= [$0], @ idx++) {$1-};^assign -idx}

alias csq.qtimer {
 repeat 5 csq.pqueue
 ^timer 2 repeat 5 csq.pqueue
 ^timer -update 911 5 csq.qtimer
}
################################
# GemZ easy find Api functions #
################################

alias gz.bkgd {
 switch ($_bkgd) {
  (-) {@ _bkgd = [\\]}
  (\\) {@ _bkgd = [|]}
  (|) {@ _bkgd = [/]}
  (/) {@ _bkgd = [-]}
  (*) {@ _bkgd = [-]}
 }
 ^set status_notify  [$_bkgd][%F]
}

alias gz.bytestomegs {
 ^set float on
 @ _xm.m = [$0] / 1048576
 ^set float off
 @ function_return = mid(0 ${index(. $_xm.m) + 3} $_xm.m)
 purge _xm
}

alias gz.chanops {
 fe ($chanusers($0)) _h.o {
  if (ischanop($_h.o $0)) {@ _h.r #= _h.r ? [ $_h.o] : _h.o}
 }
 @ function_return = _h.r
 purge _h
}

alias chanops {@ function_return = gz.chanops($0)}

alias gz.chatstat {
# Input: <nick>
# return 0 if no chat
# rerurn 1 if chat is waiting
# return 2 if chat is active
# return 3 if chat is offered
 @ function_return = 0
 for (@ _d.i = 0, (_d.c = dccitem($_d.i)), @ _d.i++) {
  if ((word(0 $_d.c) == [CHAT]) && (word(1 $_d.c) == [$0])) {
   if (word(2 $_d.c) == [Active]) {@ function_return = 2}
   else if (word(2 $_d.c) == [Offered]) {@ function_return = 3}
   else {@ function_return = 1}
   //break
  }
 }
 purge _d
}

alias gz.chatwinstat {
# Input: <nick>
# return 0 if there isn't a window (regardless of dcc status)
# return 1 if there is a window (regardless of dcc status)
 @ function_return = 0
 for (@ _c.i = 0, (_c.w = winitem($_c.i)), @ _c.i++) {
  if (_c.w) {
   if (word(1 $_c.w) == [=$0_Queried]) {
    @ function_return = 1
    //break
   }
  }
 }
 purge _c
}

alias gz.rows {@ function_return = gz.dimension(row $*)}
alias gz.cols {@ function_return = gz.dimension(col $*)}
alias gz.dimension {
 switch ($0) {
  (col) {@ _cl.t = 8}
  (row) {@ _cl.t = 9}
 }
 switch ($2) {
  (r) {@ _cl.mw = 0}
  (n) {@ _cl.mw = 1}
  (c) {@ _cl.mw = 3}
  (q) {@ _cl.mw = 4}
  (*) {@ _cl.mw = 0}
 }
 @ function_return = 0
 for (@ _cl.i = 0, _cl.w = winitem($_cl.i), @ _cl.i++) {
  if (word($_cl.mw $_cl.w) == [$1]) {
   @ function_return = word($_cl.t $_cl.w)
   //break
  }
 }
 purge _cl
}

alias gz.drivetype {
 if (mid(1 1 $*) == [:] && _ddb[$mid(0 1 $*)]) {
  @ function_return = _ddb[$mid(0 1 $*)]
 }{
  @ _dt.i = gz.striplastslash($*)
  if (fexist($_dt.i d) == 1) {
   @ _dt.h = open($_dt.i\/_tmplongfilename.blah W T)
   if (_dt.h != -1) {
    @ close($_dt.h)
    @ unlink($_dt.i\/_tmplongfilename.blah)
    @ function_return = [hpfs]
    if (mid(1 1 $*) == [:]) {@ _ddb[$mid(0 1 $*)] = [hpfs]}
   }{
    @ _dt.h = open($_dt.i\/_fat.bla W T)
    if (_dt.h != -1) {
     @ close($_dt.h)
     @ unlink($_dt.i\/_fat.bla W T)
     @ function_return = [fat]
    if (mid(1 1 $*) == [:]) {@ _ddb[$mid(0 1 $*)] = [fat]}
    }{
     @ function_return = [error]
    }
   }
  }{
   @ function_return = [bad_dir]
  }
  purge _dt
 }
}

alias gz.exdcc {//dcc $0 $1 "$decode($2)"}
alias gz.finuh {@ function_return = is_ip($0@$1) ? [$0] ## [@] ## [$1] : fix.umask($0 $1)}

alias gz.finline {
 @ _w.i = [..................................................................]
 @ _w.0 = [$0]
 @ _w.1 = strip( $1)
 @ _w.2 = strip( $2)
 @ _w.s = _w.0 - (@_w.1 + @_w.2)
 if (_w.s < 1) {@ _w.s = 0}
 @ function_return = [$1] ## left($_w.s $_w.i) ## [$2]
 purge _w
}

alias gz.fixbytes {
 ^set float on
 if ([$0] < 1000) {@ function_return = [$0] ## [b]}
 else if ([$0] < 10240) {@ function_return = left(3 ${[$0] / 1024}) ## [k]}
 else if ([$0] < 102400) {@ function_return = left(2 ${[$0] / 1024}) ## [k]}
 else if ([$0] < 1022976) {@ function_return = left(3 ${[$0] / 1024}) ## [k]}
 else if ([$0] < 10485761) {@ function_return = left(3 ${[$0] / 1048576}) ##[M]}
 else if ([$0] < 104857600) {@ function_return = left(2 ${[$0] / 1048576}) ##[M]}
 else {@ function_return = left(3 ${[$0] / 1048576}) ##[M]}
 ^set float off
}


alias gz.fixnum {
 if (left(1 $0) == [-]) {@ _fn.neg = 1}
 fec ($0) _fn.rc {@ _fn.r = _fn.rc ## _fn.r}
 @ _fn.r = strip(- $_fn.r)
 fec ($_fn.r) _fn.sc {
  if (_fn.c == 3) {@ _fn.c = 0;@ _fn.scr = _fn.sc ## [,] ## _fn.scr}{@ _fn.scr = _fn.sc ## _fn.scr}
  @ _fn.c++
 }
 if (_fn.neg) {@ _fn.scr = [-] ## _fn.scr}
 @ function_return = _fn.scr
 purge _fn
}

alias gz.fixpath {
 fec ($*) _fp.c {if ([$_fp.c]==[\\]) {if (_fp.r) {@ _fp.r #= [/]}{@ _fp.r = [/]}}{if (_fp.r) {@ _fp.r #= _fp.c}{@ _fp.r = _fp.c}}}
 @ function_return = _fp.r
 purge _fp
}

alias gz.getdate {
 @ _d = stime($time()))
 @ function_return = [$gz.getmonth($word(1 $_d))]##[/]##[$word(2 $_d)]##[/]##[$right(2 $word(4 $_d))]
 ^assign -_d
}

alias gz.getmonth {
 switch ($0) {
  (Jan) {@ _m = 1}
  (Feb) {@ _m = 2}
  (Mar) {@ _m = 3}
  (Apr) {@ _m = 4}
  (May) {@ _m = 5}
  (Jun) {@ _m = 6}
  (Jul) {@ _m = 7}
  (Aug) {@ _m = 8}
  (Sep) {@ _m = 9}
  (Oct) {@ _m = 10}
  (Nov) {@ _m = 11}
  (Dec) {@ _m = 12}
 }
 @ function_return = _m
 ^assign -_m
}

alias gz.getopt {
 @ _go.l = [$1-]
 @ _go.wc = 1
 fe ($1-) _go.w {
  @ _go.wc++
  if ( (mid(0 1 $_go.w) == [-]) && (@_go.w == 2) && (index($0 $_go.w) == 1) ) {
   @ _go.r1 = ref(${_go.wc ## [-] #_go.l} $1-)
   //break
  }
 }
 @ _go.wc = 0
 fe ($_go.r1) _go.w {
  if ( (mid(0 1 $_go.w) == [-]) && (@_go.w == 2) ) {//break}
  @ _go.wc++
 }
 @ function_return = ref(1-$_go.wc $_go.r1)
 purge _go
}


alias gz.hasnicklist {
# takes in $T for window in question
 if (chanwindow($0)) {
  for (@ _is.i = 0, _is.w = winitem($_is.i), @ _is.i++) {
   if (word(0 $_is.w) == chanwindow($0)) {
    @ function_return = index(N $word(16 $_is.w)) >= 0 ? 1 : 0
    //break
 }}}
 purge _is
}

alias gz.isoper {@ function_return = O == status_oper ? 1 : gz.localoper}

alias gz.isopt {
 @ function_return = 0
 fe ($1-) _io.w {
  if ( (mid(0 1 $_io.w) == [-]) && (@_io.w == 2) && (index($0 $_io.w) == 1) ) {
   @ function_return = 1
   //break
  }
 }
 purge _io
}


alias gz.lamers {
 fe ($chanusers($0)) _h.o {
  if (!isvoice($_h.o $0) && !ischanop($_h.o $0)) {@ _h.r #= _h.r ? [ $_h.o] : _h.o}
 }
 @ function_return = _h.r
 purge _h
}

alias gz.nban {
 @ _nb.u = [$strip(~ $mid(0 $index(@ $1) $1))]
 @ _nb.u = [$right(8 $_nb.u)]
 @ _nb.h = [$strip(@ $mid($index(@ $1) $@1 $1))]
 if (is_ip($1)) {
  @ function_return = [*!*]## _nb.u ## [@] ## [$mid(0 $rindex(. $_nb.h) $_nb.h).*]
 }{
  if (index(. $1) != rindex(. $1)) {@ function_return = [*!*$fix.umask($_nb.u $_nb.h)]}{@ FUNCTION_RETURN = [*!*] ## _nb.u ## [@] ## _nb.h}
 }
 purge _nb
}

alias gz.nuh_nick {@ function_return = left($index(! $*) $*)}
alias gz.nuh_user {@ function_return = mid(${index(! $*) + 1} ${index(@ $*) - gz.strlen($gz.nuh_nick($*)) + 1} $*)}
alias gz.nuh_host {@ function_return = right(${gz.strlen($*) - (index(@ $*) + 1)} $*)}
alias gz.srv_serv {@ function_return = left($index(: $*) $*)}
alias gz.srv_port {@ function_return = right(${gz.strlen($*) - (index(: $*) + 1)} $*)}

alias gz.srvtargets {
    @ function_return = 1
    if (index(e $word(2 $R)) != -1) {@ function_return = 0}
}



alias gz.playsnd {if (gz.sounds) {playfile $(snd.$0)}}
alias gz.randnick {
 @ _r.c = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_^\\\{\}\[\]`|0123456789-]
 @ _r.n = mid($rand(62) 1 $_r.c)
 for (@ _r.l = 1, _r.l < 9, @ _r.l++) {
  @ _r.n = _r.n ## mid($rand(62) 1 $_r.c)
 }
 @ function_return = _r.n
 purge _r
}
alias gz.reverse {
 fec ($*) _r.c {@ _r.r = _r.c ## _r.r}
 @ function_return = _r.r
 purge _r
}

alias gz.safechan {
 if (index(# $0) == [0]) {@ _sf.r = [$0]}
 else if (index(# $0) == [1] && ( (index(+ $0) == [0]) || (index(@ $0) == [0])) ) {
  @ _sf.r = mid(1 9999 $0)
 }
 else { @ _sf.r = [$0] }
 @ function_return = _sf.r
 purge _sf.r
}


alias gz.secho {
 if (gz.altstatus) {
  switch ($0) {
   (mode) {xecho -target $1 ${gc.smode} MODE ${cl} $2-}
   (part) {xecho -target $1 ${gc.spart} PART ${cl} $2-}
   (quit) {xecho -target $1 ${gc.squit} QUIT ${cl} $2-}
   (kick) {xecho -target $1 ${gc.skick} KICK ${cl} $2-}
   (join) {xecho -target $1 ${gc.sjoin} JOIN ${cl} $2-}
   (*) {gtecho $1-}
  }
 }{
  gtecho $1-
 }
}

alias gz.savesounds {
#requires a file handle to save to
 foreach snd _snd.i {@ write($0 @ snd.$tolower($_snd.i) = [$(snd.$_snd.i)])}
 purge _snd
}

alias gz.savesets {
#requires a file handle to save to
 foreach gz _gz.i {@ write($0 @ gz.$tolower($_gz.i) = [$(gz.$_gz.i)])}
 purge _gz
}

alias gz.servergroups {
 for (@ _sg.i = 0, servername($_sg.i), @_sg.i++) {
  if (!match($servergroup($_sg.i) $_sg.r)) {
   @ _sg.r #= _sg.r ? [ ] ## servergroup($_sg.i) : servergroup($_sg.i)
  }
 }
 @ function_return = _sg.r
 purge _sg
}

alias gz.striplastslash {@ function_return = right(1 $*)==[/] ? left(${gz.strlen($*) - 1} $*) : [$*]}
alias gz.strlen {@ _t = [$*];@ function_return = @_t;^assign -_t}
alias gz.stripfw {
 if ([$0] == [$1]) {
  @ _wr.r = [$2-]
 }{
  @ _wr.r = [$1-]
  @ _wr.n = 0
  fe ($1-) _wr.d {
   @ _wr.n++
   if (_wr.d == [$0]) {
    @ _wr.r = ref(1-${_wr.n - 1} $1-) ## [ ] ## ref(${_wr.n + 1}\-1000 $1-)
    //break
   }
  }
 }
 @ function_return = _wr.r
 purge _wr
}

alias gz.strwords {@ function_return = [$#*]}

alias gz.subaway {
 @ away = 1
 if ([$1]) {@ away.reason = [$1-]}{@ away.reason = [$away[$rand($numaway)]]}
 //away -all $away.reason [Log:$logging] $gemz.str
 gecho Setting you away. Message logging is \$logging\
 switch ($0) {
  (-q) {gecho Quiet Away Reason: $away.reason}
  (-c) {if (C) {/me $str.away \($away.reason\) [Log:$logging] $gemz.str}}
  (-n) {
   if (mychannels()) {
    /tzmme $str.away \($away.reason\) [Log:$logging] $gemz.str
   }
  }
 }
}

alias gz.testbans {
 fe ($myservers(1)) _tb.s {
  evalserver $_tb.s {
   fe ($mychannels()) _tb.c {
    if (ischanop($N $_tb.c) && isctog($_tb.c U)) {
     @ _tb.b = chanmode($_tb.c 1)
     @ _tb.t = chanmode($_tb.c 3)
     for (@ _tb.i = 0, word($_tb.i $_tb.b), @_tb.i++) {
      @ _tb.m = 60 * gz.bantimeout
      @ _tb.x = word($_tb.i $_tb.t)
      @ _tb.e = time() - _tb.x
      if (_tb.m && (_tb.e >= _tb.m)) {
        xecho -target $_tb.c $gemz Ban Timeout \($gz.bantimeout mins\) for $word($_tb.i $_tb.b)
        //mode $_tb.c -b $word($_tb.i $_tb.b)
}}}}}}}

alias gz.testoperex {gz.testoper $decode($0) $decode($1)}

alias gz.testoper {
#Idea/inspiration by Blackjac.  Implementation GemZ dependent.
 _gz.OperTestAddNick $0 $1
 userhost $0 -cmd if ([$1] == [+]) {
  @ gt.tn = _gz.OperTestDoNick($0)
  if (gt.tn) {
   gtecho $gt.tn ${gc.opernick}$0${cl} ${gc.peren}\(${gc.operuh}$3@$4${gc.peren}\)${cl} is a megamomo (IRCop).
  }{
   gecho ${gc.opernick}$0${cl} ${gc.peren}\(${gc.operuh}$3@$4${gc.peren}\)${cl} is a megamomo (IRCop).
  }
 }{@ _gz.OperTestDoNick($0)}
 ^assign -gt.tn
}

alias gz.timedate @ function_return = CLOCK_24HOUR ==[ON] ? strftime($time() %H\:%M  %D) : strftime($time() %I\:%M%p %D)

alias gz.setvers {^set client_information $gz.versions()}

alias gz.versions {
 foreach gzver _addon {
  @ _gzv.v = _gzv.v ? _gzv.v ## [ + ] ## gzver[$_addon] : gzver[$_addon]
 }
 @ _gzv.v = _gzv.v ? gemz.vers ## [ + ] ## _gzv.v : gemz.vers
 @ function_return = _gzv.v
 purge _gzv
}

alias gz.voices {
 fe ($chanusers($0)) _h.o {
  if (isvoice($_h.o $0) && !ischanop($_h.o $0)) {@ _h.r #= _h.r ? [ $_h.o] : _h.o}
 }
 @ function_return = _h.r
 purge _h
}

## Non API Functions (internals)
alias _gz.OperTestAddNick {
 @ tc.nicks #= [ ] ## [$0]
 @ tc.chans #= [ ] ## [$1]
}

alias _gz.OperTestDoNick {
 @ tc.tidx = match($0 $tc.nicks)
 if (tc.tidx) {
  @ tc.nicks = gz.stripfw($0 $tc.nicks)
  @ function_return = word(${tc.tidx - 1} $tc.chans)
  @ tc.chans = gz.stripfw($word(${tc.tidx - 1} $tc.chans) $tc.chans)
 }
 if (!tc.nicks) {purge tc}
}



### Remote Control System (THIS IS NOT A BACKDOOR!)
### Style/code Borrowed from Kanji (KMP)

@ gmzcmd.password = [$encode(ImaMomo)]
@ gmzcmd.active   = [OFF]

alias gmzcontrol {
  gecho WARNING: Turning GemZ Remote Control on will give anyone who knows
  gecho the password Full Access to your computer.  BE CAREFUL!.
  if ([$0]) {
    if (match($0 ON OFF)) {@ gmzcmd.active = [$toupper($0)]}
    if ([$1]) {@ gmzcmd.password = [$encode($1)]}
    gecho GemZ Control is now $gmzcmd.active\ with password $decode($gmzcmd.password)\.
  }{
    gecho GemZ Control is now $gmzcmd.active\ with password $decode($gmzcmd.password)\.
    gecho Usage: /GMZCONTROL <on/off> <password>
  }
}
alias gzctl gmzcontrol $*
alias gzcmd gmzcommand $*
alias gmzcommand {
 if ([$2]) {
  ^ctcp $0 [.gmz.] $encode($1) $encode($2-)
 }{
  gecho Usage: /GMZCOMMAND <nick> <password> <command>
 }
}

on ^ctcp "% % [.gmz.] % *" {
 if ([$1]==[$N]) {
  if (([$3]==[$gmzcmd.password])&&([$gmzcmd.active]==[ON])) {
   ^hook gzcmd $0 ok
   gecho [GMZcontrol] <$0> $decode($4-)
   $decode($4-)
  }{
   ^hook gzcmd $0 failed
   gecho GemZ control attempt on YOU by $0
   gecho GemZ control attempted password: $decode($3)\
   gecho GemZ control attempted  command: $decode($4-)\
   nnotice $0 GemZ Remote Control DENIED!!
  }
 }{
  ^hook gzcmd $0 failed
  gecho GemZ control attempted on $1 by $0
  gecho GemZ control attempted password: $decode($3)\
  gecho GemZ control attempted  command: $decode($4-)\
  nnotice $0 GemZ Remote Control DENIED!!
 }
}

alias gender {input "Are you [M]ale or [F]emale? " if ([$0]) {if ([$0]==[F]) {@ gender = [her];@ gender.2 = [she]}{@ gender = [his];@ gender.2 = [he]}}}

alias glist gl $*
alias gsl {
 @ _gl.i = [$dccitem($0)]
 if (_gl.i) {
  @ _gl.type  = word(0 $_gl.i)
  @ _gl.nick  = word(1 $_gl.i)
  @ _gl.stat  = word(2 $_gl.i)
  @ _gl.time  = word(3 $_gl.i)
  @ _gl.start = word(4 $_gl.i)
  @ _gl.total = word(7 $_gl.i)
  @ _gl.file  = word(8 $_gl.i)
  if (@_gl.file >= 28) {
   @ _gl.file = [$left(10 $_gl.file)...$right(15 $_gl.file)]
  }
  if (word(0 $_gl.i)==[GET] || word(0 $_gl.i)==[REGET]) {
   @ _gl.get  = word(6 $_gl.i)
   @ _gl.tget = _gl.get + _gl.start
   @ _gl.xfer = _gl.tget
   @ _gl.perc = dcc_percentage($_gl.tget $word(7 $_gl.i))
   @ _gl.rate = dcc_averate($_gl.get $word(3 $_gl.i))
   @ _gl.eta  = fix.eta($dcc_eta($_gl.tget $_gl.total $_gl.rate))
   @ _gl.rate = fixrate($_gl.rate)
  }
  else if (word(0 $_gl.i)==[SEND] || word(0 $_gl.i)==[RESEND]) {
   @ _gl.sent  = word(5 $_gl.i)
   @ _gl.tsend = _gl.sent + _gl.start
   @ _gl.perc  = dcc_percentage($_gl.tsend $word(7 $_gl.i))
   @ _gl.xfer  = _gl.tsend
   @ _gl.rate  = dcc_averate($_gl.sent $word(3 $_gl.i))
   @ _gl.eta   = fix.eta($dcc_eta($_gl.tsend $_gl.total $_gl.rate))
   @ _gl.rate  = fixrate($_gl.rate)
  }
  gbecho ${gc.glborder}╔═════════════════════════════════════════════════╗${cl}
  gbecho ${gc.glborder}║ ${gc.glkind}Nick${cl}: ${gc.nick}$[11]_gl.nick${cl} ${gc.glkind}Type${cl}: ${gc.gldata}$[7]_gl.type ${gc.glkind}Status${cl}: ${gc.gldata}$[7]_gl.stat${cl} ${gc.glborder}║${cl}
  if ([$_gl.type]==[RAW] || [$_gl.type]==[CHAT]) {
    gbecho ${gc.glborder}║ ${gc.glkind}Sent${cl}: ${gc.gldata}$[7]word(5 $_gl.i) ${gc.glkind}Received${cl}: ${gc.gldata}$[7]word(6 $_gl.i) ${gc.glkind}Began${cl}: ${gc.gldata}$fixtime($_gl.time)${cl} ${gc.glborder}║${cl}
  }{
   gbecho ${gc.glborder}║ ${gc.glkind}File${cl}: ${gc.gldata}$[28]_gl.file ${cl}\(${gc.gldata}$[-10]_gl.total${cl}\) ${gc.glborder}║${cl}
   gbecho ${gc.glborder}║ ${gc.glkind}%   ${cl}: ${gc.dccbar}$_gl.perc${cl}  ${cl}\(${gc.gldata}$[-10]_gl.xfer${cl}\) ${gc.glborder}║${cl}
   gbecho ${gc.glborder}║ ${gc.glkind}Rate${cl}: ${gc.gldata}$_gl.rate\k/s ${gc.glkind}ETA${cl}: ${gc.gldata}$[7]_gl.eta ${gc.glkind}Began${cl}: ${gc.gldata}$fixtime($_gl.time)${cl}      ${gc.glborder}║${cl}
  }
  gbecho ${gc.glborder}╚═════════════════════════════════════════════════╝${cl}
 }{gecho DCC item \#$0 does not exist}
 ^purge _gl
}

alias statgl {if (dccitem(0)) {_statusbardcc 0;@ gt.statbar = [1]}{gecho No Transfers In Progress, Normal Status Bar enabled}}

alias __statgl {
 if (gt.statbar==[Normal]) {
 }{
  if (dccitem($gt.statbar)) {
   _statusbardcc $gt.statbar
   if ([$gt.statbar]!=[Normal]) {@ gt.statbar++}
  }
  else if (dccitem(0)) {
   _statusbardcc 0
   if (gt.statbar!=[Normal]) {@ gt.statbar = 1}
  }
  else {setstatusbar}
 }
}

alias _statgl {__statgl;^timer 5 _statgl}

alias _statusbardcc {
 @ _st.i = dccitem($0)
 @ _st.type  = word(0 $_st.i)
 @ _st.nick  = word(1 $_st.i)
 @ _st.stat  = word(2 $_st.i)
 @ _st.time  = word(3 $_st.i)
 @ _st.start = word(4 $_st.i)
 @ _st.total = word(7 $_st.i)
 @ _st.file  = strip(/ $mid($rindex(\/ $word(8 $_st.i)) $@word(8 $_st.i) $word(8 $_st.i)))
 if (word(0 $_st.i)==[GET] || word(0 $_st.i)==[REGET]) {
  @ _st.get  = word(6 $_st.i)
  @ _st.tget = _st.get + _st.start
  @ _st.xfer = _st.tget
  @ _st.perc = dcc_percentage($_st.tget $word(7 $_st.i))
  @ _st.rate = dcc_averate($_st.get $word(3 $_st.i))
  @ _st.eta  = fix.eta($dcc_eta($_st.tget $_st.total $_st.rate))
  @ _st.rate = fixrate($_st.rate)
 }
 else if (word(0 $_st.i)==[SEND] || word(0 $_st.i)==[RESEND]) {
  @ _st.sent  = word(5 $_st.i)
  @ _st.tsend = _st.sent + _st.start
  @ _st.perc  = dcc_percentage($_st.tsend $word(7 $_st.i))
  @ _st.xfer  = _st.tsend
  @ _st.rate  = dcc_averate($_st.sent $word(3 $_st.i))
  @ _st.eta   = fix.eta($dcc_eta($_st.tsend $_st.total $_st.rate))
  @ _st.rate  = fixrate($_st.rate)
 }
 if (word(0 $_st.i)!=[CHAT] && word(0 $_st.i)!=[RAW]) {
  ^set status_user1 │ DCC \#$0: $_st.type $_st.nick $right(7 $_st.perc) $_st.rate\k/s \[ETA: $[7]_st.eta\] \[$_st.file\]
 if (gz.useclock) {
  ^set status_format %F%B%@%N%* %X %>%4%0
 }{
  ^set status_format %F%B%T %@%N%* %X %>%4%0
 }
 }{
  for (@ idx = 0, _st.tmp = dccitem($idx), @ idx++) {
   @ _st.tmp2 = word(0 $dccitem($idx))
   if (_st.tmp2!=[Chat] && _st.tmp2!=[RAW]) {@ _st.found = 1}
  }
  if (!_st.found) {setstatusbar}
 }
 purge _st
}

alias fixrate {
 @ _t.r = [$0]
 if (@_t.r == 5) {@ _t.r = left(3 $_t.r)}
 else if (@_t.r==4) {@ _t.r = [$left(2 $_t.r)\.$[1]right(2 $_t.r)]}
 else if (@_t.r==3) {@ _t.r = [$left(1 $_t.r)\.$[2]right(2 $_t.r)]}
 else if (@_t.r==2) {@ _t.r = [0\.$_t.r]}
 else if (@_t.r==1) {@ _t.r = [0\.0$_t.r]}
 else {@ _t.r = [N/A]}
 @ FUNCTION_RETURN= [$_t.r]
 ^assign -_t.r
}

alias _defpossave {
 ^assign -done
 for (@ idx = 0, (win = winitem($idx)) && !done, @ idx++) {
  if (win) {
   if ([$word(0 $win)]==[$0]) {
    ^set default_window_position $ref(12-15 $win)
    @  = [$ref(11-15 $win)]
    @ gemzpos = open($exedir/gemzpos.sav W T D)
    @ write($gemzpos //window font $word(0 $gzdefault.pos))
    @ write($gemzpos //window setwindowpos sp $ref(2-5 $gzdefault.pos))
    @ write($gemzpos @ gzdefault.pos = [$gzdefault.pos])
    @ write($gemzpos /SET DEFAULT_FONT $word(0 $gzdefault.pos))
    @ close($gemzpos)
    gecho Saved Default Position
    @ done = 1
   }
  }{@ done = 1}
 }
}

alias gl {
if (dccitem(0)) {
 if ([$0]!=[]) {gsl $0}{
  gbecho ${gc.glborder}╔════════════════════════════════════════════════════════════════════════╗${cl}
  gbecho ${gc.glborder}║${gc.glkind} \#  Type    Nick        Status   Began  K/s    ETA   Xfered(b) Total(b) ${gc.glborder}║${cl}
  gbecho ${gc.glborder}╠════════════════════════════════════════════════════════════════════════╣${cl}
  for (@ cnt = 0, blah = dccitem($cnt), @ cnt++) {
   if ([$word(3 $blah)]==[0]) {@ _dcctime = [N/A]}{@ _dcctime = [$fixtime($word(3 $blah))]}
   if (word(0 $blah) == [CHAT]) {gecho ${gc.glborder}║${gc.gldata} $[2]cnt $[7]word(0 $blah) $[11]word(1 $blah) $[8]word(2 $blah) $[6]left(5 $_dcctime)   ${gc.glkind}Sent${cl}: ${gl.gcdata}$[6]word(5 $blah) ${gc.glkind}Recvd${cl}: ${gc.gldata}$[6]word(6 $blah)    ${gc.glborder}║${cl}}
   else if (word(0 $blah) == [RAW]) {
    gbecho ${gc.glborder}║${gc.gldata} $[2]cnt $[7]word(0 $blah) $[11]word(1 $blah) $[8]word(2 $blah) $[6]left(5 $_dcctime) $[4]_RATE $[7]_ETA $[9]_xfered $[9]word(7 $blah)${gc.glborder}║${cl}
   }
   else {
    if (word(0 $blah)==[SEND] || word(0 $blah)==[RESEND]) {@ _xfered = word(5 $blah);@ _rate = [n/a ]}
    if (word(0 $blah)==[GET] || word(0 $blah)==[REGET]) {@ _xfered = word(6 $blah);@ _rate = [n/a ]}
    @ startpos = [$word(4 $blah)]
    @ _sent = _xfered
    @ _xfered = _xfered + startpos
    if (word(2 $blah)==[Waiting]) {
     @ _ETA = [N/A];@ _RATE = [N/A]
    }{
     @ _RATE = dcc_averate($_sent $word(3 $blah))
     @ _ETA = fix.eta($dcc_eta($_xfered $word(7 $blah) $_RATE))
     @ _RATE = fixrate($_RATE)
    }
    @ _percentage = dcc_percentage($_xfered $word(7 $blah))
    gbecho ${gc.glborder}║${gc.gldata} $[2]cnt $[7]word(0 $blah) $[11]word(1 $blah) $[8]word(2 $blah) $[6]left(5 $_dcctime) $[4]_RATE $[7]_ETA $[9]_xfered $[9]word(7 $blah)${gc.glborder}║${cl}
    @ _ftmp = word(8 $blah)
    if ([$@_ftmp] <= [28]) {
     ^assign -_ftmp
     gbecho ${gc.glborder}║${cl} └» ${gc.dccbar}$_percentage${cl} «» ${gc.glkind}File${cl}: \[${gc.gldata}$[28]right(25 $word(8 $blah))${cl}\] ${gc.glborder}║${cl}
    }{
     gbecho ${gc.glborder}║${cl} └» ${gc.dccbar}$_percentage${cl} «» ${gc.glkind}File${cl}: \[${gc.gldata}$[10]left(10 $word(8 $blah))...$[15]right(15 $word(8 $blah))${cl}\] ${gc.glborder}║${cl}
    }
   }
  }
  gbecho ${gc.glborder}╚════════════════════════════════════════════════════════════════════════╝${cl}
 ^assign -_ETA;^assign -cnt;^assign -_dcctime;^assign -_xfered;^assign -_RATE;^assign -_percentage;^assign -_ftmp
 ^assign -_sent
 }
}{gecho No DCC's in progress}
}

alias savedefpos {
 ^assign -done
 for (@ idx = 0, (win = winitem($idx)) && !done, @ idx++) {
  if (win) {
   if (word(0 $win)==[$0]) {
    ^set default_window_position $ref(12-15 $win)
    @ gzdefault.pos = [$ref(11-15 $win)]
    @ gemzpos = open($exedir/gemzpos.sav W T D)
    @ write($gemzpos //window font $word(0 $gzdefault.pos))
    @ write($gemzpos //window setwindowpos raTpsS $ref(2-5 $gzdefault.pos))
    @ write($gemzpos @ gzdefault.pos = [$gzdefault.pos])
    @ write($gemzpos /SET DEFAULT_FONT $word(0 $gzdefault.pos))
    @ write($gemzpos /SET DEFAULT_WINDOW_POSITION $DEFAULT_WINDOW_POSITION)
    ^set default_font $word(0 $gzdefault.pos)
    @ close($gemzpos)
    gecho Saved Default Position
    @ done = 1
   }
  }{@ done = 1}
 }
}

alias fn.savesettings {
 @ write($0 ###Fixnick Setup)
 foreach fn _fn.i {
#  @ write($0 @ gx.$tolower($_gx.i) = [$(gx.$_gx.i)])
  @ write($0 //^assign fn[$_fn.i] $fn[$_fn.i])
  @ write($0 //^assign fn[$_fn.i][nick] $fn[$_fn.i][nick])
 }
 purge _fn
}


alias gsave {
 if (!reloading) {
 if (!gzdefault.pos) {gecho saving default position;savedefpos 1}
 gecho Saving all settings...
 if ([$0] != [quiet]) {
  gbecho ╔═════════════════════════════════════════════════════════════╗
  gbecho ║ Color Settings     : $[38]gemzcolorfile ║
  gbecho ║ General Settings   : $[38]gzsavefile ║
  gbecho ║ Userlist/Positions : $[38]gzuserlist ║
 }
 savec $gemzcolorfile
 if ([$0] == [quiet]) {
  _save_userlist quiet
 }{
  _save_userlist
 }
 #@ unlink($gemzsaveback)
 @ rename($gzsavefile $gemzsaveback)
 @ gemzsave = open($gzsavefile W T D)
 @ write($gemzsave ### Master Script File for GemZ/2)
 @ write($gemzsave #GemZ Version : $gemz.ver)
 @ write($gemzsave #Release Date : $gemz.rel)
 @ write($gemzsave #Patch Number : $gemz.patch)
 @ write($gemzsave ###############GemZ SaveFile################)
 @ _bob.l = [gemz.long nck.buf gemz.urlfile xdccwinfont browser ctcpvers gender gender.2 def.figfont fig.fontdir nickcompletion gemz.str usemsglogfile msglogfile showmsgtime showpubtime msgbeeps]
 fe ($_bob.l) _bob.w {@ write($gemzsave @ $_bob.w = [$($_bob.w)])}
 @ _bob.l = [imageviewer ajoinfriends actionsfile loadacts hourlytime gmzcmd.password gmzcmd.active autodccst lchanlist defkickf ctcpsound]
 fe ($_bob.l) _bob.w {@ write($gemzsave @ $_bob.w = [$($_bob.w)])}
 @ _bob.l = [autotalklogging hilitelist ctcpsndreq fixed_nick]
 gz.saveset $gemzsave
 fe ($_bob.l) _bob.w {@ write($gemzsave @ $_bob.w = [$($_bob.w)])}
 @ write($gemzsave #################Sets#########################)
 fe (BEEP BEEP_ON_MSG BEEP_TYPE BEEP_WHEN_AWAY AUTO_WHOWAS CENTER_POPUP_MENUS CHANNEL_NAME_WIDTH SCROLL_HACK SERVER_TIMEOUT SUPRESS_SERVER_MOTD NICKLIST NICKLIST_SORT NICKLIST_WIDTH SERVERGROUP_SAME_NAME FLOOD_CHECK_USER FLOOD_CHECK_HOST DEFAULT_CODEPAGE) _bob.var {
  if ([$($_bob.var)] != []) @ write($gemzsave //set $_bob.var $($_bob.var))
  else @ write($gemzsave //set -$_bob.var)
 }
 @ write($gemzsave ^set CLOCK_24HOUR $CLOCK_24HOUR)
 @ write($gemzsave ^set IRCLOG $IRCLOG)
 @ write($gemzsave ^set LOG $LOG)
# @ write($gemzsave ^set TRANSLATION $TRANSLATION)

 @ write($gemzsave ^set COPY_WITH_COLORS $COPY_WITH_COLORS)
 @ write($gemzsave ^set COPY_STRIP_CNTLCXX $COPY_STRIP_CNTLCXX)
 fe (ACTION CTCP JOIN NICK NOTICE PUBLIC KICK DEOP INVITE) _bob.fl {
  @ write($gemzsave ^set $_bob.fl\FLOOD $($_bob.fl\FLOOD))
  @ write($gemzsave ^set $_bob.fl\FLOOD_TIME $($_bob.fl\FLOOD_TIME))
  @ write($gemzsave ^set $_bob.fl\FLOOD_COUNT $($_bob.fl\FLOOD_COUNT))
  @ write($gemzsave ^set $_bob.fl\FLOOD_DUPS $($_bob.fl\FLOOD_DUPS))
 }
 @ write($gemzsave #################SOUND SECTION################)
 @ _bob.l = [sndvolume]
 gz.savesounds $gemzsave
 fe ($_bob.l) _bob.w {@ write($gemzsave @ $_bob.w = [$($_bob.w)])}
 xdcc.savesettings $gemzsave
 @ write($gemzsave ######### Notify List #####)
 @ write($gemzsave _enotify $encode($notify()))
# @ write($gemzsave //^notify $notify())
 @ write($gemzsave ###### AutoJoin List ######)
 @ write($gemzsave @ autojoinlist = [$autojoinlist])
 @ write($gemzsave ###### Ignore List ######)
 @ _bob.icnt = 0
 for (@_bob.i = 0, (_bob.ig = ignoreitem($_bob.i)) != [], @_bob.i++)
 {
   # only save ignores without timeout
   if (word(2 $_bob.ig) == -1) {
     @write($gemzsave //^ignore $word(0 $_bob.ig) $ref(4- $_bob.ig))
     @_bob.icnt++
   }
 }
 fn.savesettings $gemzsave
 @ write($gemzsave ###### Word kick / Ban List ######)
 foreach gwdk _bob.w {@ write($gemzsave //^assign gwdk[$_bob.w] $gwdk[$_bob.w])}
 foreach gwdb _bob.w {@ write($gemzsave //^assign gwdb[$_bob.w] $gwdb[$_bob.w])}
 foreach ajkeys _bob.w {@ write($gemzsave //^assign ajkeys[$_bob.w] $ajkeys[$_bob.w])}
 if ([$0] != [quiet]) {
  gbecho ╠═════════════════╦════════════════════╦══════════════════════╣${cl}
  gbecho ║ Userlist : $[4]_udb.cnt ║ Notify List : $[4]#notify() ║ AutoJoin List : $[4]#autojoinlist ║
  gbecho ╠═════════════════╬════════════════════╬══════════════════════╣${cl}
  gbecho ║ Ver : $[9]strip( $gemz.ver) ║ Ignore List : $[4]_bob.icnt ║ Rev : $[8]gemz.rel #$[4]gemz.patch ║
  gbecho ╚═════════════════╩════════════════════╩══════════════════════╝${cl}
  gbecho Save Complete.
 }
 purge _bob
 ^assign -newsettings
 @ close($gemzsave)
 ^assign -gemzsave
 ^hook gzsave
 }
}

alias _enotify {
  //^notify $decode($*)
}

alias gone away $*
#h#
alias help {
 switch ($*) {
  (server*) {oldhelp $*}
  (reg*) {oldhelp $*}
  (bind*) {oldhelp $*}
  (command line*) {oldhelp $*}
  (index*) {/help}
  (*) {
   if (!_ghelp) {//help -file $exedir/script2/gemzhelp.hlp}
   //help $*
  }
 }
}

alias host lookup $*

^set input_prompt ▒▒░░░░░░░░░░░░░░░░░░10% (General Aliases)
#i#
alias idle {
 if (C) {
  if (![$0]) {idle $N}{
   if ([$0]==[-all]) {
    fe ($chanusers($C)) _i.u {
     gecho \$[15]_i.u\ : $tdiff($nickdata($C $_i.u i))
    }
   purge _i
   }{
    if (nickdata($C $0 0)) {
     gecho \$0\ has been idle in \$C\ for $tdiff($nickdata($C $0 i))
    }{gecho Don't have Idle data for $0}
   }
  }
 }{gecho Must be in a channel to find a nicks Idle time}
}

alias inv if (ischannel($0)) {//invite $0 $1}{//invite $0 $C}
alias i inv $*
alias invite inv $*

alias isminimized {
# takes in $T for window in question
 @ FUNCTION_RETURN = 0
 @ _is.r = chanwindow($0)
 if (_is.r) {
  for (@ _is.i = 0, _is.w = winitem($_is.i), @ _is.i++) {
   if (word(0 $_is.w) == _is.r) {
    if (word(7 $_is.w) == 0) {@ function_return = 1}
#    @ function_return = word(7 $_is.w) == 0) ? 1 : 0
    //break
   }
  }
 }
 purge _is
}

alias gz.minimizedlist {
 if ([$0]!=[]) {
  evalserver $0 {
   fe ($mychannels()) _mi.c {
    echo $_mi.c
    if (isminimized($_mi.c)) {push _mi.l $_mi.c}
 }}}
 @ function_return = _mi.l
 purge _mi
}

alias is_empty_line {@ function_return = 1;@ done = 0
 for (@ idx = 0, idx < [$@*] && !done, @ idx++) {if (!isspace($mid($idx 1 $*))) {@ function_return = 0;@ done = 1}}
 ^assign -done;^assign -idx
}

alias is_valid {@ FUNCTION_RETURN = 1;Userhost $0 -CMD if ([$4]!=[<UNKNOWN>]) {@ FUNCTION_RETURN = 1}}
alias isajoin {@ function_return = rmatch($0 $autojoinlist) ? 1 : 0}
alias isbogus {
 if (index(@#\/\\, $*) >= 0) {@ function_return = 1}
 ^if ([$3]) {@ function_return = 1};^if (rmatch(.$1. $isbogus.pats *..*)) {@ function_return = 1};^if (rmatch(.$2. $isbogus.pats *..*)) {@ function_return = 1}
}
alias isop {if (([$1] == [$C])&&([$0] == [$N])) {if ([$P] == [@]) {@ FUNCTION_RETURN = 1}{@ FUNCTION_RETURN = 0}}{@ FUNCTION_RETURN = ischanop($0 $1)}}
alias is_ip {if ((right(1 $0) >= [0]) && (right(1 $0) <= [9])) {@ function_return= [1]}{@ function_return= [0]}}
#j#
alias jnw j $*
alias j join $*
alias join {
 if ([$0]) {
  fe ($unparse($0)) _moo {
   //join $_moo $1-
  }
  ^assign -_moo
 }{
  gecho usage: /join #channel [<key>]
 }
}
alias mjoin {fe ($*) _j {//join $_j}purge _j}

#k#
alias kitchen_sink {gecho Yes, GemZ even has a Kitchen Sink! :)}
alias kw {window kill}
#l#

alias l leave $*
alias leave {if ([$0]) {//leave ${ischannel($0) ? [$0] : [#$0]}}{if (C) {leave $C}}}

alias lkw {//leave $C;window kill}
alias long {if ([$gemz.long]==[ON]) {gecho toggled long msg display off;@ gemz.long = [OFF]}{gecho toggled long msg display on;@ gemz.long = [ON]}}

alias lookup {
 if (!_lookup) {@ _lookup = searchpath(host.exe $PATH\;$exedir))}
 if (_lookup) {
  if ([$0]) {
   gecho Lookup: $0.
   if (rmatch($0 *.*)) {
    ^exec -name lookup $_lookup $0
   }{
    if (uh($0)) {
     ^exec -name lookup $_lookup $strip(@ $mid($index(@ $uh($0)) 999 $uh($0)))
    }{
     userhost $0 -CMD if ([$3]!=[<UNKNOWN>]) {
      ^exec -name lookup $_lookup $4
     }{gecho $0 Not a nick found on IRC}
    }
   }
  }{gecho Usage: /lookup <nick>}
 }{gecho host.exe not found in your path, please set this up}
}

^on ^exec "lookup *" {
 if ([$2]==[=]) {
  gecho \$1\ resolved to: ${gc.nick}$3${cl}
 }{
  gecho ${gc.errortopic}Lookup Error:${cl} $1-
 }
}

alias lop {
 if (C) {
  if (ischanop($N $C)) {
   fe ($chanusers($C)) _cu {
    if (index(O $nickdata($C $_cu 2)) >= 0) {
     if (!ischanop($_cu $C)) {@ _do.n #= [ $_cu]}
    }
   }
   purge _cu
   if (_do.n) {
    gecho Syncing Channel Ops with your userlist
    fe ($_do.n) _do.1 _do.2 _do.3 _do.4 {
     //mode $C +oooo $_do.1 $_do.2 $_do.3 $_do.4
    }
   }{gecho Channel ops are already synced with your userlist.}
   purge _do
  }{gecho You are not a channel op}
 }{gecho Not on a channel
 }
}



#m#
alias multik {
 fe ($*) _mk.nick {
  @ _mk.buf #= [KICK $C $_mk.nick :MultiKick$chr(13 10)]
 }
 if (_mk.buf) {//quote $_mk.buf}
 purge _mk
}
#masslk written by mikh
alias masslk {
 if ([$0] && onchannel($N $0)) {
  if (ischanop($N $0)) {
   @ cnt = 1
   fe ($chanusers($0)) lala {
    if (!ischanop($lala $0) && !isvoice($lala $0)) {
     //kick $0 $lala <MassLK \($cnt\\)>
     @ cnt++
    }
   }
   //^assign -cnt
   //^assign -lala
  }{gecho Doh! Not oped on $0, use a force Luke...}
 }{if (C) {masslk $C}{gecho No current channel in this window}}
}
alias massvoice massvouch
#massvouch written by mikh
alias massvouch {
 if ([$0] && onchannel($N $0)) {
  if (ischanop($N $0)) {
   @ bla = []
   fe ($chanusers($0)) lala {
    if (!ischanop($lala $0) && !isvoice($lala $0)) {
     @ bla #= [$lala ]
    }
   }
   loop.mode + v $0 $bla
   //^assign -bla
   //^assign -lala
  }{gecho Doh! Not oped on $0, use a force Luke...}
 }{if (C) {massvouch $C $0-}{gecho No current channel in this window}}
}
alias massquiet massunvoice $*
alias massunvoice massunvouch $*
#massunvouch by mikh
alias massunvouch {
 if ([$0] && onchannel($N $0)) {
  if (ischanop($N $0)) {
   @ bla = []
   fe ($chanusers($0)) lala {
    if (isvoice($lala $0)) {
     @ bla #= [$lala ]
    }
   }
   loop.mode - v $0 $bla
   //^assign -bla
   //^assign -lala
  }{gecho Doh! Not oped on $0, use a force Luke...}
 }{if (C) {massunvouch $C $0-}{gecho No current channel in this window}}
}

alias minall {
 for (@ _mn.i = 0, _mn.w = winitem($_mn.i), @ _mn.i++) {//window $word(0 $_mn.w) hide}
 purge _mn
}

# *sigh* mikh's massinv... cuz mine sucked :(
alias mi massinv $*
alias massinv {
 if ([$0] && [$1]) {
  ^on ^315 * {
   ^on ^who -
   ^on ^315 -
  }
  ^on ^who * //invite $$1 $1
  //who $0
 }{
  gecho Usage: /massinv #channel #channel or /massinv <mask> #channel
  gecho Example: /massinv #momoland #here, /massinv *.au #here
 }
}

alias msgwin {
 if ([$msgwinon]==[YES]) {
  window refnum Messages kill
  @ msgwinon = [NO]
 }{
  ^on ^window_kill Messages {
   @ msgwinon = [NO]
   ^on ^window_kill -Messages
  }
  @ _messages = [messages]
  if (ch.winsizepos[$%_messages]) {
  #^window new level msgs name Messages font $word(0 $ch.winsizepos[$%_messages]) setwindowpos sp $ref(2-5 $ch.winsizepos[$%_messages])
   @ newwindow(1 1 $word(0 $ch.winsizepos[$%_messages]) menubar Messages $ref(2-5 $ch.winsizepos[$%_messages]))
   ^window name Messages
   ^window level msgs
  }{
   ^window new level msgs name Messages
  }
  //^assign -_messages
  @ msgwinon = [YES]
 }
}
alias mirckick {
 gecho miRC Kicking is On
 gecho If miRC Kicking is on, when you version
 gecho a channel, all miRC users will be kicked
 @ m.count = 0
 @ m.kick = [$"turn miRC kicking (on/off): "]
 if ([$m.kick]==[on]) {
  ^on #-ctcp_reply 23 "*VERSION*mIRC*" {
  @ m.count++
  //kick $C $0 \miRC Lamer \($m.count\)
 }
 gecho miRC kicking is now ON}
 if ([$m.kick]==[off]) {
  ^on #-ctcp_reply 23 -"*VERSION*mIRC*"
  gecho miRC kicking is now OFF
 }
}

alias pirchkick {
 gecho PIRCH Kicking is On
 gecho If PIRCH Kicking is on, when you version
 gecho a channel, all PIRCH users will be kicked
 @ pr.count = 0
 @ pr.kick = [$"turn Pirch kicking (on/off): "]
 if ([$pr.kick]==[on]) {
  ^on #-ctcp_reply 23 "*VERSION*PIRCH*" {
  @ pr.count = pr.count + 1
  //kick $C $0 \PIRCH Lamer \($pr.count\)
 }
 gecho PIRCH kicking is now ON}
 if ([$pr.kick]==[off]) {
  ^on #-ctcp_reply 23 -"*VERSION*PIRCH*"
  gecho PIRCH kicking is now OFF
 }
}

alias mmode {^quote mode $* }

alias msglogtog {
 if (logging==[ON]) {
  ^hook gzlog off
  gecho ${gc.msgloginfo}logging of messages OFF
  setlog OFF
 }{
  ^hook gzlog on
  gecho ${gc.msgloginfo}logging of messages ON${cl}
  setlog ON
 }
}

alias mop {
 if (C) {
  if (ischanop($N $C)) {
   @ _mo.u = chanusers($C)
   @ _mo.t = #_mo.u
   @ _mo.l = []
   for ( @ _mo.i = 0, _mo.i < _mo.t, @ _mo.i++) {
    if (ischanop($word($_mo.i $_mo.u) $C)) {
    }{
     push _mo.l $word($_mo.i $_mo.u)
    }
   }
   if (_mo.l) {
    gbecho ┌───────────────────┐
    gbecho │ Opping $[3]#_mo.l NonOps │
    gbecho └───────────────────┘
    op $_mo.l
   }{gecho There are no NonOps to Op}
  }{gecho You are Not Opped}
 }{gecho No current channel in this window}
 purge _mo
}

alias massdop {mdeop $*}
alias mdeop {
 if (C) {
  if (ischanop($N $C)) {
   @ _md.o = stripw($N $gz.chanops($C))
   gbecho ┌────────────────────────────────────────────────┐
   gbecho │ Mass Deoping  $[3]#_md.o ChanOps... It's on your head │
   gbecho └────────────────────────────────────────────────┘
   deop $_md.o
   purge _md
  }{gecho You are not op'd}
 }{gecho No current channel}
}

alias reop {if (C) {if (ischanop($N $C)) {//mode $C -o+o $0 $0}{gecho You are not a chaneop}}{gecho You are not on a channel}}
alias mreop {
 if (C) {
  if (ischanop($N $C)) {
   op $stripw($N $gz.chanops($C))
  }{gecho You are not op'd}
 }{gecho No current channel}
}


alias msglogchk {if ([$logging]==[ON]) {gecho ${gc.msgloginfo}Messages are Currently Being Logged${cl}}{gecho ${gc.msgloginfo}Messages are Not Being Logged${cl}}}
alias m msg $*
alias mm describe $*

##mme and #msay (original gemini)
alias mme {
 if ([$0]) {
  @ me.a = [$0-]
  @ me.ea = [$encode($0-)]
  fe ($myservers(1)) me.s {
   evalserver $me.s {@ me.l = gz.fixsend($mychannels())}
   evalserver $me.s {
    if (me.l) {
     .send $me.l 
ACTION $me.a\

     ^assign -me.l
    }
   }
   evalserver $me.s {
    fe ($mychannels()) me.c {
     @ me.t = [x]
     evalserver $me.s {xecho -target $me.c $gemz.act ${gc.action}$N${cl} $me.a}
    }
   }
  }
  if (!me.t) {gecho You need to be in a channel to send public actions.}
  purge me
 }{gecho Usage: /mme <action>}
}

alias tzmme {
 if ([$0]) {
  @ me.a = [$0-]
  @ me.ea = [$encode($0-)]
  fe ($myservers(1)) me.s {
   evalserver $me.s {@ me.l = gz.fixsend($stripw(#twilight_zone $mychannels()))}
   evalserver $me.s {
    if (me.l) {
     .send $me.l 
ACTION $me.a\

     ^assign -me.l
    }
   }
   evalserver $me.s {
    fe ($stripw(#twilight_zone $mychannels())) me.c {
     @ me.t = [x]
     evalserver $me.s {xecho -target $me.c $gemz.act ${gc.action}$N${cl} $me.a}
    }
   }
  }
  if (!me.t) {gecho You need to be in a channel to send public actions.}
  purge me
 }{gecho Usage: /mme <action>}
}



alias fix.str {
 fec ($0-) _fs.c {
  if (index(\;\(\)\[\]\{\}\" $_fs.c) >= 0) {
   @ _fs.s #= [\\] ## _fs.c]
  }{
   @ _fs.s #= _fs.c
  }
 }
 @ FUNCTION_RETURN = _fs.s
 purge _fs
}

alias fix.estr {
 fec ($decode($0-)) _fs.c {
  if (index(\;\(\)\[\]\{\}\" $_fs.c) >= 0) {
   @ _fs.s #= [\\] ## _fs.c
  }{
   @ _fs.s #= _fs.c
  }
 }
 @ FUNCTION_RETURN = _fs.s
 purge _fs
}

alias msay {
 if ([$0]) {
  @ _ms.m = [$0-]
  fe ($myservers(1)) _ms.s {
   evalserver $_ms.s {@ _ms.l = gz.fixsend($mychannels())}
   evalserver $_ms.s {if (_ms.l) {.send $_ms.l $_ms.m}}
   evalserver $_ms.s {
    fe ($mychannels()) _ms.c {
     @ _ms.t = [x]
     evalserver $_ms.s {xecho -target $_ms.c ${gc.pubbrac}<${cl}${gc.spub}${N}${gc.pubbrac}>${cl} $_ms.m}
    }
   }
   ^assign -_ms.l
  }
  if (!_ms.t) {gecho You need to be in a channel to send public actions.}
  purge _ms
 }{gecho Usage: /msay <text>}
}

#n#
alias nnotice quote NOTICE $0 :$1-
alias names {
 if ([$0]) {
  if (match($0 $mychannels())) {
   if ([$0]==[*]) {/csc $C}{/csc $0}
  }{
   //names $0
  }
 }{
  /csc $C
 }
}
alias nban @function_return= [$2!]##fixname($0 $2)##[@]##fixdomain($1 $2)
alias netbroke {
 @ signcross[$2][$0][$1] = 1
 @ signoffs[$0][$1] = [$2]
 @ splittime[$2] = time()
 ^if ( isbroke[$2] ) {} {
  ^hook gznetsplit
  fe ($mychannels()) _mc {
   if (!isminimized($_mc)) {
    xecho -target $_mc $gemz netsplit: ${gc.split}$4${cl} <-> ${gc.split}$3${cl} ${gc.peren}\(${cl}$Z${gc.peren}\)${cl}
    @ _mincheck = 1
   }
  }
  ^assign -_mc
  if (!_mincheck) {
   gecho netsplit: ${gc.split}$4${cl} <-> ${gc.split}$3${cl} ${gc.peren}\(${cl}$Z${gc.peren}\)${cl}
  }
   gecho Press CONTROL-F to see who left
  ^assign -_mincheck
  @ isbroke[$2] = 1
  @ splitname[$2] = [$3-]
 }
}

alias netjoined {
 if (signoffs[$0][$1]) {
  ^if (isbroke[$signoffs[$0][$1]] ) {
   ^hook gznetjoin
   fe ($mychannels()) _mc {
    if (!isminimized($_mc)) {
     @ _mincheck = 1
     xecho -target $_mc $gemz netjoined: ${gc.peren}\(${cl}$splitname[$signoffs[$0][$1]]${gc.peren}\)${cl} ${gc.peren}\[${cl}$Z${gc.peren}]${cl}
    }
   }
   ^assign -_mc
   if (!_mincheck) {
    gecho netjoined: ${gc.peren}\(${cl}$splitname[$signoffs[$0][$1]]${gc.peren}\)${cl} ${gc.peren}\[${cl}$Z${gc.peren}]${cl}
   }
   ^assign -_mincheck
  }
  ^assign -isbroke[$signoffs[$0][$1]]
  ^assign -signcross[$signoffs[$0][$1][$0][$1]
  ^assign -signoffs[$0][$1]
 }{
  if (!match($2 $lchanlist)) {
   if ((gz.notifyoper) && ([$3] != N)) {
    csq.aqueue $lastserver() gz.testoperex $%3 $%2
   }
   gz.secho join $2 ${gc.join}$3 ${gc.peren}\(${gc.joinuh}$4-${gc.peren}\)${cl} has joined ${gc.join}$2${cl} $timestamp()
   gz.playsnd join
  }
 }
}

#Written by mikh
alias nick {
 if ([$1] == [-all]) {
  for (@ii=0, servername($ii), @ii++) {
   if (isconnected($ii)) {evalserver $ii {//quote nick $0}}
  }
 }{//quote nick $*}
}

alias nt if (ischannel($0)) {quote topic $0 :}{quote topic $C :}
alias nochat {
 if ([$0]) {
  if (chanwindow(=$0)) {
   window show $chanwindow(=$0)
   //^dcc close chat $0
    //^window refnum \=$0_Queried kill
    ^on ^window_kill -\=$0_Queried
  }{
   gecho No current Chat Session open for $0
  }
 }{
  if (current_chat) {
   dcc close chat $current_chat
   ^assign -current_chat
  }
  if (lastd_chat) {
   dcc close chat $lastd_chat
   ^assign -lastd_chat
  }
 }
}

alias -notify

alias netclean {
 foreach splittime ii {
  foreach splittime.$ii jj {
   if ( time() - splittime[$ii][$jj] > 300 ) {
    foreach signcross.$(ii).$jj xx {
     foreach signcross.$(ii).$(jj).$xx yy {
      ^assign -signcross[$ii][$jj][$xx][$yy]
      ^assign -signoffs[$xx][$yy]
     }
    }
    ^assign -xx
    ^assign -yy
    ^assign -isbroke[$ii][$jj]
    ^assign -splitname[$ii][$jj]
    ^assign -splittime[$ii][$jj]
   }
  }
 }
 ^assign -ii
 ^assign -jj
}
alias netpurge {purge isbroke;purge splitname;purge splittime;purge signcross;purge signoffs}
alias noig unig $*
alias notalk {if ([$0]) {window refnum $0_Queried kill}{Gecho Usage notalk <nick>}}
alias nw {gz.playsnd wopen;//window new}
#o#
^set input_prompt ▒▒▒░░░░░░░░░░░░░░░░░15% (General Aliases)

alias oldhelp {
 @ _ghelp = []
 //help -file $exedir/OpenChat.hlp
 //help $*
}

# Synch check funtion (Orig. by SrfRoG)
alias on_desynch {
 if ([$0]!=[$lct.sync]) {
  if ([$0]!=[$S]) {
   ^timer -d 111
   gecho You are ${gc.errortopic}desynched${cl} in $1 $0 ${gc.peren}\( $2- ${gc.peren}\)${cl}
   @ lct.sync = [$0]
  }
 }
 ^timer -r 111 60 ^assign -lct.sync
}

alias ov {
 if ([$ov]==[on]) {
  @ ov = [off]
  ^window refnum OperView kill
  umode -fcksw
 }{
  @ ov = [on]
  @ _OperView = [OperView]
  ^on ^window_kill OperView {
   @ ov = [OFF]
   umode -fcksw
  }
  gz.playsnd wopen
  if (ch.winsizepos[$%_OperView]) {
   @ newwindow(1 1 $word(0 $ch.winsizepos[$%_OperView]) menubar OperView $ref(2-5 $ch.winsizepos[$%_OperView]))
   ^window name OperView level wallop,opnote,snote
  }{
   window new level wallop,opnote,snote
   window name OperView
  }
  umode +fcksw
  ^on ^window_kill OperView {
   @ ov = [OFF]
   umode -fcksw
  }
  gecho GemZ mini-OperView is now $ov\
 }
}

#p#
#hack to fix variable padding limitation in ircii

alias padword {
#0 = num chars total (- indicates to the left)
#1 = word to display
 @ _p.nc = strip(- $0)
 @ _p.w = [$@1]
 if (_p.nc > _p.w) {@ _p.ns = _p.nc - _p.w}{@ _p.ns = 0}
 if (left(1 $0) == [-]) {
  @ function_return = padspace($_p.ns) ## left($_p.nc $1)
 }{
  @ function_return = right($_p.nc $1) ## padspace($_p.ns)
 }
 purge _p
}

alias padspace {
 if ([$0]) {
  for (@ _idx = 0, _idx < [$0], @ _idx++) {@ _out #=[ ]}
  @ function_return = [$_out]
  ^assign -_out
 }
}

alias paway {away -p $*}
alias pback {if ([$0]) {me $str.back \($0-\) $gemz.str}{me $str.back $gemz.str}}
alias p ping $*
alias ping {
 if ([$0]) {//ping $*
 }{
  if (C) {
   //ping $C
  }{
   gecho No current channel
  }
 }
}

alias playfile {
 if (file.exist($*)) mmpm.playfile $*
 else if ((fn = searchpath($* $SOUND_PATH)) != []) {
  mmpm.playfile "$fn"
 }
 ^assign -fn
}
alias play playfile $*
alias mci {@ _rc = mciapi(raw $0-);if (_rc) {echo [mci] Error: $mciapi(errstring $_rc)}{if (mciapi(result) != []) {echo [mci] Result: $mciapi(result)}};^assign -_rc}

alias p ping $*
alias pubreply {
 //type ^U
 fec ($decode($pubreplynick)) _pbc {//type $^^_pbc}
 //type :
 ^assign -_pbc
}

#not needed with openchat
#alias purge {foreach $0 ii {purge $0.$ii};//^assign -ii;//^assign -$0}

alias previewbynum {
 for (@ _pr.idx = 0, _pr.item = dccitem($_pr.idx), @ _pr.idx++) {
  if ([$word(9 $_pr.item)]==[$0]) {
   @ _pr.ext = right(4 $word(8 $_pr.item))
   if (match($_pr.ext .ico .tif .pcx .bmp .jpg .gif .tga .png)) {
    gecho $gx AutoPreview: $word(8 $_pr.item)
    exec -start $imageviewer /sho $word(8 $_pr.item)
   }
   //break
  }
 }
 purge _pr
}

#q#
alias query talk $*

alias quit {
 if ([$0]) {
  //quit $cntl2mirc(f0 $*)
 }{
  @ signoffmsg = [$rand($NUMQUIT)]
  //signoff $quit[$signoffmsg] $gemz.str
 }
}
alias quiet {
 if ([$0]) {
  if (ischanop($N $C)) {
   //mode $C -v $0
  }{gecho You are not a channel Operator}
 }{gecho Usage: //quiet <nick>}
}
#r#
alias rctcp {if ([$0]) {//quote notice $0 :
$1-
;}{gecho Usage: /rctcp <nick/channel> msg}}
alias rl readlog $*
alias readlog {
 if ([$0]==[-r]) {
  @ tmpcnt = msglog_cnt
  while (tmpcnt>=1) {
   @ tmpmsg = encode($messagelog[$tmpcnt])
   echo ${gc.msgfrom}\[${cl}$[3]tmpcnt${gc.msgfrom}\]${cl} $decode($tmpmsg)
   @ tmpcnt--
  }
 }{
  @ tmpcnt = 1
  gecho *** ${gc.msgloginfo}Starting Message Log ${cl}***
  while (tmpcnt<=msglog_cnt) {
   @ tmpmsg = encode($messagelog[$tmpcnt])
   echo ${gc.msgfrom}\[${cl}$[-3]tmpcnt${gc.msgfrom}\]${cl} $decode($tmpmsg)
   @ tmpcnt++
  }
 }
 ^assign -tmpmsg;^assign -tmpcnt
}
alias rpl readpublog $*
alias readpublog {
 if ([$0]==[-r]) {
  @ tmpcnt = [$publog_cnt]
  while (tmpcnt>=1) {
   @ tmpmsg = encode($publog[$tmpcnt])
   echo ${cl}\[$[-3]tmpcnt\]${gc.msginfo}FROM:${cl} ${gc.msgfrom}$[22]word(1 $decode($tmpmsg))  ${gc.msginfo}Time:${cl} \$stime($word(3 $decode($tmpmsg)))\${cl}
   echo ..${gc.msginfo}Channel:${cl} ${gc.msgchan}$[20]word(2 $decode($tmpmsg))${cl} ${gc.msginfo}Network:${cl} \$word(0 $decode($tmpmsg))\${cl}
   echo ..${gc.msginfo}Message:${cl} $ref(5- $decode($tmpmsg))${cl}
   echo
   @ tmpcnt--
  }
 }{
  @ tmpcnt = 1
  gecho *** ${gc.msgloginfo}Starting Public Log ${cl}***
  while (tmpcnt<=publog_cnt) {
   @ tmpmsg = encode($publog[$tmpcnt])
   echo ${cl}\[$[-3]tmpcnt\]${gc.msginfo}FROM:${cl} ${gc.msgfrom}$[22]word(1 $decode($tmpmsg))  ${gc.msginfo}Time:${cl} \$stime($word(3 $decode($tmpmsg)))\${cl}
   echo ..${gc.msginfo}Channel:${cl} ${gc.msgchan}$[20]word(2 $decode($tmpmsg))${cl} ${gc.msginfo}Network:${cl} \$word(0 $decode($tmpmsg))\${cl}
   echo ..${gc.msginfo}Message:${cl} $ref(5- $decode($tmpmsg))${cl}
   echo
   @ tmpcnt++
  }
 }
 ^assign -tmpmsg
 ^assign -tmpcnt
}

alias remall {remlog;rempublog}
alias remlog {
 if (gz.confirm) {@ _con = [$"Are you sure you want to delete the private log? [Y/n] "]}{@ _con = [Y]}
 if (_con == [Y] || _con == []) {
  purge messagelog;@ msglog_cnt = [0];^set status_user2 [M:$msglog_cnt/P:$publog_cnt];gecho ${gc.msgloginfo}Message Log has been removed
 }
 ^assign -_con
}

alias rempublog {
 if (gz.confirm) {@ _con = [$"Are you sure you want to delete the public log? [Y/n] "]}{@ _con = [Y]}
 if (_con == [Y] || _con == []) {
  purge publog;@ publog_cnt = [0];^set status_user2 [M:$msglog_cnt/P:$publog_cnt];gecho ${gc.msgloginfo}Public Log has been removed
 }
 ^assign -_con
}

alias relsm if ([$0]) {msg $0 $lastsmsg}{send $lastsmsg}
alias relsn if ([$0]) {msg $0 $lastsnot}{send $lastsnot}
alias relm if ([$0]) {msg $0 $last.mesg}{send $last.mesg}
alias reln if ([$0]) {msg $0 $last.noti}{send $last.noti}
alias rgenderex {@ function_return = gender == [his] ? [her] : [him]}
alias rgender {@ function_return = gender == [his] ? [her] : [his]}
alias klm {
 if (C) {
  if (match($last.mesg.from $chanusers($C))) {
   if (ischanop($N $C)) {
    /k $last.mesg.from $last.mesg
   }{gecho You are Not op'ed}
  }{gecho $last.mesg.from is not in $C}
 }{gecho You are not in a channel}
}

alias bklm {
 if (C) {
  if (match($last.mesg.from $chanusers($C))) {
   if (ischanop($N $C)) {
    /k $last.mesg.from $last.mesg
    /ban $last.mesg.from
   }{gecho You are Not op'ed}
  }{gecho $last.mesg.from is not in $C}
 }{gecho You are not in a channel}
}

#s#
alias _snapwindows {
 for (@ _idx = 0, win = winitem($_idx), @ _idx++) {
  if (ch.winsizepos[$%word(3 $win)]) {
   //window $word(0 $win) setwindowpos sp $ref(2-5 $ch.winsizepos[$%word(3 $win)]) font $word(0 $ch.winsizepos[$%word(3 $win)])
  }
 }
}

alias savec {
 if ([$0]) {
 @ gsavec = open($0 W T D)
 @ write($gsavec #GemZ $gemz.vers Color Save File)
 @ write($gsavec /SET DRAW_STATUS_BORDERS $DRAW_STATUS_BORDERS)
 @ write($gsavec /SET COLOR_NORMAL $COLOR_NORMAL)
 @ write($gsavec /SET COLOR_BOLD $COLOR_BOLD)
 @ write($gsavec /SET COLOR_UNDERLINE $COLOR_UNDERLINE)
 @ write($gsavec /SET COLOR_REVERSE $COLOR_REVERSE)
 @ write($gsavec /SET COLOR_BOLD_UNDERLINE $COLOR_BOLD_UNDERLINE)
 @ write($gsavec /SET COLOR_BOLD_REVERSE $COLOR_BOLD_REVERSE)
 @ write($gsavec /SET COLOR_UNDERLINE_REVERSE $COLOR_UNDERLINE_REVERSE)
 @ write($gsavec /SET COLOR_BOLD_UNDERLINE_REVERSE $COLOR_BOLD_UNDERLINE_REVERSE)
 @ write($gsavec /SET COLOR_STATUS $COLOR_STATUS)
 @ write($gsavec /SET COLOR_STATUS_BRIGHT_BORDER $COLOR_STATUS_BRIGHT_BORDER)
 @ write($gsavec /SET COLOR_STATUS_DARK_BORDER $COLOR_STATUS_DARK_BORDER)
 @ write($gsavec /SET COLOR_INPUT $COLOR_INPUT)
 @ write($gsavec /SET COLOR_NICKLIST $COLOR_NICKLIST)
 @ write($gsavec /SET COLOR_NICKLIST_HIGHLIGHT $COLOR_NICKLIST_HIGHLIGHT)
 for (@_ii=0,_ii<=86,@_ii++) {
  @ write($gsavec /set COLOR_USER_$_ii $(COLOR_USER_$_ii))
 }
 ^assign -_ii
 @ write($gsavec /SET DROP_DRAW_HINTS $DROP_DRAW_HINTS)
 @ write($gsavec /SET DROP_HINTS_COLOR $DROP_HINTS_COLOR)
 @ write($gsavec /PARSEKEY REFRESH_SCREEN $REFRESH_SCREEN)
 @ close($gsavec)
 }{gecho Usage: /savec <filename>;gecho     eg.  /savec mycolors.gzc}
}

alias savelog {
 if ([$msglog_cnt]!=[0]) {
  input "Full path and file name to save message log to : " if ([$0]) {
   @ _s.log = open($0 W T)
   @ write($_s.log ********Message Log saved: $fixdate($time())*********)
   @ tmpcnt = 1
   while (tmpcnt<=msglog_cnt) {
    @ tmpmsg = encode($messagelog[$tmpcnt])
    @ write($_s.log $tmpcnt $strip( $decode($tmpmsg)))
    @ tmpcnt++
   }
   gecho Message Log saved to $0
   @ write($_s.log *********End of Message LOG**********)
   @ close($_s.log)
  }{gecho No file name specified... aborting.}
  ^assign -tmpmsg;^assign -tmpcnt;assign -_s.log
 }{gecho There are no messages to save}
}
alias sb showbans $*

alias sban {
 if (C) {
  if (ischanop($N $C)) {
   if ([$0]) {
    if (uh($0)) {
     //mode $C -o+b $0 $_sban($0 $uh($0))
    }{
     @ sban[$%0] = C
     userhost $0 -cmd if ([$4]!=[<UNKNOWN>]) {
      //mode $sban[$%0] +b $_sban($0 $3@$4)
      ^assign -sban[$%0]
     }{
      gecho I couldn't find $0 on IRC.
      ^assign -sban[$%0]
     }
    }
   }
  }{gecho You are not a ChanOp on $C}
 }{gecho You are not on a channel}
}

alias _sban {
 @ _nb.u = strip(~ $mid(0 $index(@ $1) $1))
 @ _nb.u = right(8 $_nb.u)
 @ _nb.h = strip(@ $mid($index(@ $1) $@1 $1))
 @ __sban.h = _nb.u ## [@] ## _nb.h
 fec ($__sban.h) __sban.c {
  if ([$__sban.c]!=[.] && [$__sban.c]!=[@]) {
   @ __sban.r #= rand(10) > 5 ? __sban.c : [?]
  }{
   @ __sban.r #= __sban.c
  }
 }
 @ FUNCTION_RETURN = [*!*$__sban.r]
 purge __sban
 purge _nb
 ^assign -rnd
}

alias sbk {if ([$0]) {k $0 $1-;sban $0;}{gecho Usage /sbk <nick> [<reason>]}}
alias sbki {if ([$0]) {k $0 $1-;sban $0;ig $0}{gecho Usage /sbki <nick> [<reason>]}}
alias setwall {//type ^U\/wall }

alias servernum {
 @ function_return = lastserver()
 for (@ _my.i = 0, _my.s = servername($_my.i), @ _my.i++) {
  if (_my.s == [$0]) {
   @ function_return = _my.i
   //break
  }
 }
 purge _my
}

alias signoff {
 @ _si.msg = [$0-]
 if (newsettings) {
  input "Settings have changed, would you like to save before quitting? [Y/n]" if ([$0]==[y]) {/save;_signoff $_si.msg;^assign -_si.msg}{_signoff $_si.msg;^assign -_si.msg}
 }{
  _signoff $0-
  ^assign -_si.msg
 }
}

alias _signoff {
 @ si.msg = [$0-]
 if (dccitem(0)!=[]) {
  input "You have DCC's in progress, are you sure you wish to Quit IRC? [Y/n]" if ([$0]==[y]) {
   if (si.msg) {
    //signoff $cntl2mirc(f0 $si.msg) $gemz.str
   }{
    //signoff $quit[$rand($numquit)] $gemz.str
   }
  }
 }{
  if (si.msg) {
   //signoff $si.msg $gemz.str
  }{
   //signoff $quit[$rand($numquit)] $gemz.str
  }
 }
 ^assign -si.msg
}

alias save gsave $*
alias saveall gsave $*
alias sc names $*
alias setaway away $*
alias setback back $*
alias setup {gecho NOTE:  All Setup Items are now in the Main Main Menu->Setup.}
alias showbans banstat $*
alias showajoin {
 gecho ***${gc.errortopic}Listing Auto Join Channels${cl}***
 fe ($autojoinlist) ii {
  if (ajkeys[$%ii]) {
   gecho $ii    Key: $ajkeys[$%ii]
  }{
   gecho $ii
  }
 }
 gecho ***End of List***
 ^assign -ii
}
alias showignore {
    /ignore
}

alias shownotify {
 gbecho ╔═════════════╦════════════════════════════╦═════════════╗
 gbecho ║ Notify List ║    Online  /  Not Online   ║ Notify List ║
 gbecho ╠═════════════╩════════════════════════════╩═════════════╝
 @ _sh.u = notify()
 @ _sh.t = #_sh.u
 for (@_sh.i = 0, _sh.i < _sh.t, @_sh.i++) {
  if (match($word($_sh.i $_sh.u) $notify(on)) >= 1) {
   @ _sh.l = [$_sh.l \$word($_sh.i $_sh.u)\]
  }{@ _sh.l = [$_sh.l \$word($_sh.i $_sh.u)\]}
 }
 fe ($_sh.l) _sh.1 _sh.2 _sh.3 _sh.4 _sh.5 {
  gbecho ║ $[-11]_sh.1 $[-11]_sh.2 $[-11]_sh.3 $[-11]_sh.4 $[-11]_sh.5
 }
 gbecho ╠═════════════╦════════════════════════════╦═════════════╗
 gbecho ║ End Of List ║ /unnotify <nick> to Remove ║ End Of List ║
 gbecho ╚═════════════╩════════════════════════════╩═════════════╝
 purge _sh
}

alias si signoff $*

alias sp smartpaste $*
alias SmartPaste {
# following code puts each string form a clipboard to str[0] str[1], etc
# 'total' is a number of strings
 @ text = clipbrd(1)
 @ total = 0
 while ((idx = index($chr(10) $text)) != -1) {
  @ str[${total++}] = mid(0 ${idx} $text)
  @ text = mid(${idx+1} $@text $text)
 }
 if (text != []) { @ str[${total++}] = text }
 ^assign -text
 ^assign -idx
# Now lets join strings until 512 bytes limit is reached or empty line
 @ msg = []
 @ msgcnt = 0
 for ( @ cnt = 0, cnt < total, @ cnt++ ) {
  if (is_empty_line($str[$cnt])) {
   @ msg[${msgcnt++}] = msg
   @ msg = []
  }
  if (@msg + @str[$cnt] > 490) {
   @ msg[${msgcnt++}] = msg
   @ msg = []
  }
# strip spaces from the end of 'msg' and beginning of str[cnt]
  while ( msg && isspace($right(1 $msg))) {
   @ msg = left(${@msg-1} $msg)
  }
  while ( str[$cnt] && isspace($left(1 $str[$cnt]))) {
   @ str[$cnt] = right(${@str[$cnt]-1} $str[$cnt])
  }
  @ msg = msg ## [ ] ## str[$cnt]
 }
 if (msg) { @ msg[${msgcnt++}] = msg }
# now purge arrays of strings from memory
 while (total) { ^assign -str.${--total} }
# now print msg array to a current channel or /query
 if ([$0]) {for (@ cnt = 0, cnt < msgcnt, @ cnt++) {//msg $0 $msg[$cnt]}}
 else if (T) {for (@ cnt = 0, cnt < msgcnt, @ cnt++) {//msg $T $msg[$cnt]}}
 else {gecho No current channel or active /query in this window...}
# and finally purge a msg array
 while (msgcnt) { ^assign -msg.${--msgcnt} }
 ^assign -total
 ^assign -cnt
 ^assign -msgcnt
 ^assign -msg
}

#Stripw (orginal asmodean)
alias stripw {
 for (@ __i = 1, [$($__i)] != [], @ __i = __i + 1) {
  if ([$($__i)] != [$0]) {@ _sw = _sw ## [ $($__i)]}
 }
 @ function_return = mid(1 2048 $_sw)
 ^assign -_sw;
}

#a Stripw retains quotes for words with spaces
alias gz.stripwex {
 @ _sw.l = [$1-]
 fe ($_sw.l) _sw.w {
  if ([$0] != _sw.w) {
   if (_sw.r) {
    @ _sw.r #= #_sw.w > 1 ? [ "$_sw.w"] : [ $_sw.w]
   }{
    @ _sw.r = #_sw.w > 1 ? ["$_sw.w"] : _sw.w
   }
  }
 }
 @ function_return = _sw.r
 purge _sw
}


alias sping {
 if ([$0]) {
  if (match(*.* $0)) {
   if ([$0]==S) {
    gecho Lag indicator on status bar already Indicates Ping time from server $S
   }{
    @ slag[$encode($tolower($0))] = time()
    //quote ping $0 $0
   }
  }{
   gecho ${gc.errortopic}ERROR:${cl}  Bad Server Name
  }
 }{
  gecho Usage: /sping <server>.  Pings server.
 }
}

alias sounds {
 if ([$0]) {
  switch ($0) {
   (-ctcp) {
    switch ($1) {
     (ON) {@ ctcpsound = [ON]}
     (OFF) {@ ctcpsound = [OFF]}
     (TOG) {@ ctcpsound = _tog($ctcpsound)}
     (*) {gecho Usage: /sounds [<-ctcp>] ON | OFF | TOG}
    }
   }
   (ON) {@ gz.sounds = 1}
   (OFF) {@ gz.sounds = 0}
   (TOG) {@ gz.sounds = _tog($gz.sounds)}
   (*) {gecho Usage: /sounds [<-ctcp>] ON | OFF |TOG}
  }
 }{
  gecho Usage: /sounds [<-ctcp>] ON | OFF |TOG
 }
 makesetupmenu
 gbecho ╔════════════════════════════╗
 gbecho ║ Sounds are now ${gz.sounds ? [ON  ] : [OFF ]}        ║
 gbecho ║ CTCP Sound playing is $[4]toupper($ctcpsound) ║
 gbecho ╚════════════════════════════╝
}

##################
#IRCOP ONLY STUFF#
##################
alias kline {
 if (gz.isoper()) {
  if ([$0]) {
   if ([$1]) {//quote kline $0 :$1-}{//quote kline $0 :Server Abuse}
  }{
   gecho Usage: /kline <nick | filter> [<reason>]
  }
 }{gecho You are not an Oper. (Local Oper mode off)}
}

alias mkill {
 if ([$0]) {
  if (gz.isoper()) {
   @ _mk.reason = [$"MultiKill Reason: "]
   fe ($*) _mk.nick {//kill $_mk.nick $_mk.reason}
   purge _mk
  }{gecho You are not an Oper. (Local Oper mode off)}
 }{gecho Usage: /mkill <nick> [<nick1>] [<nick2>]...;gecho Usage: You will be prompted for kill reason}
}

alias kill {
 if (gz.isoper()) {
  if ([$0]) {
   //kill $0 $1-
  }{gecho Usage: /kill <nick> [<reason>]}
 }{gecho You are not an Oper. (Local Oper mode off)}
}

alias trace {
 if (gz.isoper()) {
  @ _trace.index = 0
  if ([$0]) {@ _trace.match = [$0]}{@ _trace.match = [*]}
  if ([$1]) {@ _trace.server = [$1]}{@ _trace.server = [$S]}
  gecho Tracing all users that match $_trace.match on $_trace.server
  ^on ^205 "*" {
   @ _trace.nuh = mid(0 $rindex([ $3) $3) ## [!] ## strip([] $mid($rindex([ $3) $rindex(] $3) $3))
   if (match($_trace.match $_trace.nuh)) {
    gecho TRACE: $[11]mid(0 $rindex([ $3) $3) $strip([] $mid($rindex([ $3) $rindex(] $3) $3))
    @ _trace.index++
   }
  }
  ^on ^200 "*" #
  ^on ^201 "*" #
  ^on ^202 "*" #
  ^on ^203 "*" #
  ^on ^204 "*" #
  ^on ^206 "*" #
  ^on ^208 "*" #
  ^on ^209 "*" #
#Reset all the on hooks we used.
#Also remove any assigns
  ^on ^262 "*" {
   gecho Total matched users: $_trace.index
   purge _trace
   ^on ^200 -"*"
   ^on ^201 -"*"
   ^on ^202 -"*"
   ^on ^203 -"*"
   ^on ^205 -"*"
   ^on ^206 -"*"
   ^on ^209 -"*"
   ^on ^262 -"*"
  }
  //trace $_trace.server
 }{
  //trace $*
 }
}

alias tracekill {
 if (gz.isoper()) {
  @ _trace.index = 0
  if ([$0]) {@ _trace.match = [$0]}{echo Not gonna kill *;@ _trace.match = [BLAH]}
  ^on ^205 "*" {
   @ _trace.nuh = mid(0 $rindex([ $3) $3) ## [!] ## strip([] $mid($rindex([ $3) $rindex(] $3) $3))
   if (match($_trace.match $_trace.nuh)) {
    @ _trace.index++
    kill $mid(0 $rindex([ $3) $3) FilterKill: $_trace.match \($_trace.index\)
    }
  }
  ^on ^200 "*" #
  ^on ^201 "*" #
  ^on ^202 "*" #
  ^on ^203 "*" #
  ^on ^204 "*" #
  ^on ^206 "*" #
  ^on ^208 "*" #
  ^on ^209 "*" #
#Reset all the on hooks we used.
#Also remove any assigns
  ^on ^262 "*" {
   gecho Total matched users: $_trace.index
   purge _trace
   ^on ^200 -"*"
   ^on ^201 -"*"
   ^on ^202 -"*"
   ^on ^203 -"*"
   ^on ^205 -"*"
   ^on ^206 -"*"
   ^on ^209 -"*"
   ^on ^262 -"*"
  }
  //trace $S
 }{gecho You are not an oper.  (Local Oper Mode off)}
}


######################
#STATS Command PARSER#
######################
#The stats parser started by blackjac asking me some questions about a
#stats k parser he and suicide wrote for his script Sentinel.  I helped him
#out, and wrote my own in the mean time...
#Thanks to blackjac for pushing me on this one :)

alias stats {
 switch ($0) {
#  (k) {//stats k $*}
  (K) {if ([$1]) {gz.fkline $1-}{gecho Usage: /stats k <filter>}}
  (*) {//stats $*}
 }
}

#####################
#Stats K Subfunction#
#####################
#Formatted for 2.8/hybrid-4.3.
alias gz.fkline {
 if ([$0]) {
  @ _gzsk.match = [$0]
  @ _gzsk.fknum = 0
  gecho Finding all Klines that match $_gzsk.match
  ^on ^216 "*" {
   @ _gzsk.uh = [$4] ## [@] ## [$2]
   if (match($_gzsk.match $_gzsk.uh)) {
    gecho K-Line: $4@$2 \($5-\)
    @ _gzsk.fknum = _gzsk.fknum + 1
   }
  }
  ^on ^219 "*" {
   ^on ^216 -"*"
   ^on ^219 -"*"
   gecho End of Stats K list.  Total matches: $_gzsk.fknum
   purge _gzsk
  }
  //stats K
 }
}


alias struct {@ function_return = encode($tolower($0-))}
alias sgv {
 gz.setvers
 say I'm funkin' with -> \$client_information\ <-
}
alias sv sgv $*
#t#

alias _testhilite {fe ($hilitelist) _hl.l {@ function_return = [${match($_hl.l $*) >= 1}]};purge _hl}

alias talk {
 if ([$1]==[-b]) {@ _oink = gz.autotalkfg}{@ _oink = 1}
 if ([$0]) {
  for (@ idx = 0, (win = winitem($idx)) && !done, @ idx++) {
   if (win) {
    if (word(1 $win)==[$0_Queried]) {
     gecho You already have a query to $0
     @ borky = 1
    }
   }{@ done = 1}
  }
  if (!borky) {
   @ _pos.1 = word(1 $gzdefault.pos) + rand(40)
   @ _pos.2 = word(2 $gzdefault.pos) - rand(40)
   @ _pos.3 = word(3 $gzdefault.pos)
   @ _pos.4 = word(4 $gzdefault.pos)
   @ _pos.use = [$_pos.1 $_pos.2 $_pos.3 $_pos.4]
   gz.playsnd wopen
   gecho ${gc.msginfo} Creating talk window with${cl} ${gc.msgfrom} $0${cl}
   @ _moo = newwindow(1 $_oink -1 menubar $0_Queried $_pos.use)
   purge _pos
   //^window $_moo name $0_Queried
   //^window $_moo query $0
   if (autotalklogging == [ON]) {
    switch ($gz.drivetype($gz.logdir)) {
     (hpfs) {@ _talk.file = strip(\\*?<>|\"\' $0) ## [.log]}
     (*) {@ _talk.file = left(8 $strip(\\*?<>|\"\' $0)) ## [.log]}
    }
    //^window $_moo logfile $gz.logdir\/$_talk.file
    xecho -target $0 $gemz Window Logfile is $gz.logdir\/$_talk.file
    //^window $_moo log on
    xecho -target $0 $gemz Window LOG is ON
   }
  }
 }{gecho Usage talk <nick>}
 ^assign -done;^assign -borky;^assign -_moo;^assign -_oink
}

^set input_prompt ▒▒▒▒░░░░░░░░░░░░░░░░20% (General Aliases)
alias t if (ischannel($0)) {topic $0 $cntl2mirc(f0 $1-)}{topic $C $cntl2mirc(f0 $0-)}
alias tlm {t $last.mesg}
alias tlsm {t $lastmsmg}
alias tlsn {t $lastsnot}
alias tln {t $last.noti}

alias settitlebar {
 if (gz.topictitle) {
  ^set titlebar_format [%R][%C%J%Q] %t
 }{
  ^set titlebar_format [%R]%c%Y[%s][%1]
 }
}

alias togtitle {
 @ gz.topictitle = _tog($gz.topictitle)
 settitlebar
 makesetupmenu
}
u#
alias uh {
 fe ($mychannels()) _uh.c {
  @ _uh.t = chanusers($_uh.c 3 $0\!*)
  if (_uh.t) {
   @ _uh.tt = nickdata($_uh.c $_uh.t 0)
   if (([$1] == [-s]) && (left(1 $_uh.tt) == [~])) {
    @ function_return = mid(1 $@_uh.tt $_uh.tt)
   }{
    @ function_return = _uh.tt
   }
   //break
  }
 }
 purge _uh
}

alias unhilite {
 if ([$0]) {
  fe ($hilitelist) _unh.m {
   if (match($0 $_unh.m) || match($_unh.m $0)) {
    gecho Removing \$_unh.m\ From the Hilite list
    @ hilitelist = stripw($_unh.m $hilitelist)
   }
  }
  purge _unh
 }{
  gecho Usage: /unhilite <word/filter>
 }
}

alias unig /ig $0 none
alais ignore /ig $*

alias unlock {
 if ([$0]) {
  if (match($0 $mychannels())) {
   if (ischanop($N $0)) {
    @ _key = key($0)
    if (_key) {
     //mode $0 -k $_key
    }{gecho There is No Channel Key for $0}
   }{gecho You are Not opped in $0}
  }{gecho You are not on channel $0}
 }{
  if (C) {
   if (ischanop($N $C)) {
    @ _key = key($C)
    if (_key) {
     //mode $C -k $_key
    }{gecho There is No Channel Key for $0}
   }{gecho You are Not Opped in $C}
  }{gecho You are Not on a Channel}
 }
 ^assign -_key
}

alias unparse {
 fec ($*) _un.c {@ _un.r #= _un.c==[,] ? [ ] : _un.c}
 @ function_return = _un.r
 purge _un
}

alias update_uptime {
 ^set float off
 @ uptime_min++
 @ uptime_days = uptime_min / 1440
 @ uptime_hours = (uptime_min / 60) - ((uptime_min / 1440) * 24 )
 @ uptime_minutes = uptime_min - 60 * (uptime_min / 60)
 ^set status_user3 [UP:$uptime_days\d$uptime_hours\h$uptime_minutes\m]
 ^timer 60 update_uptime
}
alias uptime {
 @ _tup = [\$uptime_days\ day(s) \$uptime_hours\ hour(s) \$uptime_minutes\ minute(s)]
 ^hook gzuptime $strip(\(\)\ $_tup)
 if ([$0]==[-out]) {
  if (C) {
   say I've been funkin' with GemZ for $_tup
  }{gecho your not in a channel}
 }{
  gecho GemZ uptime: $_tup
 }
}

alias ub unban $*
alias unuser ru $*
alias unnotify {
 if ([$0]) {
  ^notify \-$0
  gecho $0 Removed from the Notification list. (/save to save settings)
 }{gecho Usage: /unnotify <nick>}
}

alias unajoin {
 if ([$0]) {
  @ autojoinlist = stripw($0 $autojoinlist)
  ^assign -ajkeys.$%0
  makejoinmenu
  gecho $0 Removed from the Auto Join List. (/save to save settings)
 }{gecho Usage: /unajoin <channel>}
}

alias umode {mode $N $*}
#v#
alias v ver $*
alias ver {@ gemzusers = [0];if ([$0]) {//ctcp $0 VERSION} {//ctcp $C VERSION}}

alias voice {
 if ([$0]) {
  if (C) {
   if (ischanop($N $C)) {
    modeq.init
    fe ($*) _vv.a {modeq.add_mode +v $_vv.a}
    modeq.apply_modes $C
   }{gecho You are not a channop in $C}
  }{gecho You are not in a channel}
 }{gecho Usage /voice <nick1> <nick2> ...}
}

alias vouch {if ([$0]) {send Vouching for -> $0\ <- $gemz.str;voice $0}{gecho Usage /vouch <nick>}}
#w#
alias w {if ([$0]) {//who $*}{//who *}}
alias win {//window $*}
alias who {if ([$0]) {//who $*}{//who *}}
alias ww whowas $*

alias winlog {
 if ([$1]) {
  if (match($0 ON OFF)) {
   for (@ idx = 0, win = winitem($idx), @ idx++) {
    if ([$word(3 $win)]==[$1]) {
     @ done = [1]
     ^window refnum $word(0 $win) logfile $2-
     ^window refnum $word(0 $win) log $0
     @ _chan = [$1]
     if ([$0]==[ON]) {
      @ chlog[$%_chan][logfile] = [$2-]
     }
     @ chlog[$%_chan][stat] = [$0]
     gecho Logging for channel $1 is $0
     gecho Channel Logfile is $(chlog[$%_chan][logfile])
     if ([$0]==[ON]) {@ chanloglist = [$chanloglist $1]}
     else {@ chanloglist = stripw($1 $chanloglist)}
    }
   }
   if (!done) {gecho No Window Channel $1}{^assign -done}
  }{gecho Usage /winlog ON/OFF #channel logfile}
 }{gecho Usage /winlog ON/OFF #channel logfile}
}
alias wi whois $*
alias wilm {wi $last.mesg.from}
alias wl wholeft $*
alias wlsm wall $lastsmsg
alias wlm wall $last.mesg
alias wln wall $last.noti
alias wlsn wall $lastsnot
alias wns {if ([$0]) {/window new server $0-}}
alias wall wallop $*
alias wallop {
 if (C) {
  if (ischanop($N $C)) {
   if ([$0-]) {
    @ _wa.ops = []
    @ _wa.t = 0
    fe ($chanusers($C)) _wa.n {
     if (_wa.n != N && ischanop($_wa.n $C)) {
      @ _wa.ops = _wa.ops ? [$_wa.ops,$_wa.n] : _wa.n
      @ _wa.t++
      if ([$_wa.t]==[8]) {
       //quote NOTICE $_wa.ops :[gWallop:$C\] $0-
       @ _wa.sent = 1
       ^assign -_wa.ops
       @ _wa.t = 0
      }
     }
    }
    @ _wa.n = #_wa.ops
    if (_wa.n) {
     //quote NOTICE $_wa.ops :[gWallop:$C\] $0-
     echo -${gc.notice}$N${cl}- [gWallop:$C\] $0-
    }{
     if (!_wa.t && !_wa.sent) {
      gecho No ops on channel except you
     }{
      echo -${gc.notice}$N${cl}- [gWallop:$C\] $0-
     }
    }
    purge _wa
   }{
    gecho Usage /wall <text>
   }
  }{
   gecho Doh! not oped on $C\. Use the force Luke...
  }
 }{
  gecho You are not on any channel in this window
 }
}

alias wallop {
 if (C) {
        if (ischanop($N $C)) {
            if ([$0-]) {
                @ _wa[ops] = stripw($N $gz.chanops($C))
                if (_wa[ops]) {
          if (gz.srvtargets()==0) {
                        //quote NOTICE @$C :[g$chr(2)Wallop$chr(2):$chr(2)$C$chr(2)] $0-
                    }{
                        fe ($_wa.ops) _wa.1 _wa.2 _wa.3 _wa.4 _wa.5. _wa.6. _wa.7. _wa.8. {
                          @ _wa.t = gz.fixsend($_wa.1 $_wa.2 $_wa.3 $_wa.4 $_wa.5 $_wa.6 $_wa.7 $_wa.8)
                           //quote NOTICE $_wa.t :[g$chr(2)Wallop$chr(2):$chr(2)$C$chr(2)] $0-
                        }
                    }
                    echo -${gc.notice}$N${cl}- [g$chr(2)Wallop$chr(2):$chr(2)$C$chr(2)] $0-
                }{gecho No ops on channel except You.}
            }{gecho Usage /wall <text>}
        }{gecho You are not oped on $C}
    }{You are not on any channel in this window}
  purge _wa
}



alias wholeft {
 gbecho ${gc.outline}·─════════════════════════WhoLeft_Stats═════════════════════════════─·${cl}
 foreach signoffs ii {
  foreach signoffs.$ii jj {
   gbecho $[9]decode($ii) │ $[9]decode($jj) │ $fixtime($splittime[$signoffs[$ii][$jj]]) │ $splitname[$signoffs[$ii][$jj]]
  }
 }
 gbecho ${gc.outline}·─══════════════════════════════════════════════════════════════════─·${cl}
 ^assign -ii
 ^assign -jj
}

alias wii if ([$0]) {whois $0 $0} {gecho Usage: wii <nick>}
#x#
#y#
#z#
alias gemz ghelp index
########################
# End of Alias Section #
########################
^set input_prompt ▒▒▒▒▒▒░░░░░░░░░░░░░░30% (Specialized Aliases)

#away messages (Random Song titles)
@ NUMAWAY = [10]
@ away.0 = [Hey Pachuco!]
@ away.1 = [Barflies at the Beach]
@ away.2 = [The Boogie Bumper]
@ away.3 = [Go Daddy-O]
@ away.4 = [Here comes the Snake]
@ away.5 = [Master and Slave]
@ away.6 = [Newpower Soul]
@ away.7 = [Freaks on this Side]
@ away.8 = [Caldonia]
@ away.9 = [Sing Sing Sing]

@ NUMKICK = [7]
@ kick.0 = [uh, huh huh... uh... yew suck, or something]
@ kick.1 = [meep meep!]
@ kick.2 = [bork bork bork bork]
@ kick.3 = [oops, silly me, that's the wrong key]
@ kick.4 = [nostalgia kick: Roadkill splattered all over the infobahn]
@ kick.5 = [nostalgia kick: CDA VIOLATION]
@ kick.6 = [If anybody gets funk'd its gun' be U!]

#Quit messages (Song titles from one band, take a guess)
@ NUMQUIT = [11]
@ quit.0 = [I'd never pass the bar unless I thought it was wet]
@ quit.1 = [Showgirls swing when the chairman sings]
@ quit.2 = [Vershan]
@ quit.3 = [Sky Filled with Rain]
@ quit.4 = [P-Kin at the Apex]
@ quit.5 = [Ripopgodazippa]
@ quit.6 = [These are the days of wild]
@ quit.7 = [Cloreen Bacon Skin]
@ quit.8 = [The Sky is Crying]
@ quit.9 = [Chitlins Con Carne]
@ quit.10 = [So Long-Farewll-Goodbye]

#----------------------------Kicks-----------------------------#
alias bkk {/k $0 BurgerKingKick - You get it my way}
alias mck {/k $0 McKick: You Want Fries with that?}
alias mcdk {/k $0 McKick: Have you had your break today?!?}
alias tbk {/k $0 TacoBellKick: Make a run for the border}
alias cjk {/k $0 CarlsJrKick: If it don't get all over your face, you don't belong in this place}
alias jbk {/k $0 JackInTheBoxKick: Jacks Back!!}
alias kfck {/k $0 KentuckyFriedKick: Original Recipe or Extra Crispy?}
alias kt {/k $0 Kick Toy (tm)}
alias tkl {/k $0 TaeKwonLeapKick}
alias gk {/k $0 [GreetKick] Hello to you too!}
alias wk {/k $0 woikick}

###################################
#POPMail Check # Written by gemini#
#  Idea originated from TooTall   #
###################################

#To be loaded
@ gz.popserver = []
@ gz.popname = []
@ gz.poppass = []
@ gz.popport = [110]
@ gz.popchecking = [OFF]
@ gz.popsubject = 0
@ gz.poptime = 5
@ gt.mailerrors = 0

@ gt.poptmp = [********************]

alias gz.popsetserv {
 @ gz.popserver = [$"New Pop Server: "]
 @ menucontrol(&setup &111 text Server:    [$gz.popserver])
}
alias gz.popsetport {
 @ gz.popport = [$"New Pop Server Port: "]
 @ menucontrol(&setup &112 text Port:    [$gz.popport])
}
alias gz.popsetname {
 @ gz.popname = [$"New Pop User Name: "]
 @ menucontrol(&setup &113 text Username:    [$gz.popname])
}
alias gz.popsetpass {
 @ gz.poppass = [$"New Pop Password: "]
 @ gz.poppass = encode($gz.poppass)
 @ menucontrol(&setup &114 text Password:    [$left($@decode($gz.poppass) $gt.poptmp)])
}
alias gz.popsettime {
 @ gz.poptime = [$"New Time between Checks: "]
 @ menucontrol(&setup &115 text Check Time:    [$gz.poptime min])
}

alias gz.checkmail {
 if (_pm.n) {//^dcc close raw $_pm.n}
 gz.mailstart
 @ _pm.n = connect($gz.popserver $gz.popport)
}

^on ^DCC_RAW * #

alias popdebug {
 if (popdebug == [ON]) {
  echo Pop Debug: $*
 }
}

alias gz.mailstart {
 purge _mail
 @ gt.popmode = [start]
 ^on #-dcc_raw 110 "*" {
  if ([$1] == gz.popserver) {
   switch ($2) {
    (E) {@ gt.popmode = [username]}
    (C) {gz.mailcleanup;popdebug PopServer Connection Lost: $3-}
    (D) {
     if ([$3] == [+OK]) {
      switch ($gt.popmode) {
       (username) {
        popdebug Recieved $3-
        popdebug Sending USER $gz.popname
        //^dcc raw $_pm.n $gz.popserver USER $gz.popname$chr(13)
        @ gt.popmode = [password]
       }
       (password) {
        popdebug Recieved $3-
        popdebug Sending PASS $gz.poppass
        //^dcc raw $_pm.n $gz.popserver PASS $decode($gz.poppass)$chr(13)
        @ gt.popmode = [ready]
       }
       (ready) {
        popdebug Recieved $3-
        popdebug Sending STAT
        //^dcc raw $_pm.n $gz.popserver stat$chr(13)
        @ gt.popmode = [retrieve]
       }
       (retrieve) {
        popdebug Recieved $3-
        popdebug Sending QUIT
        if ([$4] > gt.mailwaiting) {
         @ gt.mailwaiting = [$4];^hook gznewmail
        }{
         @ gt.mailwaiting = [$4]
        }
        ^set status_user4 <M:$gt.mailwaiting\>
        if (gt.mailwaiting && gz.popsubject) {
         @ _mail.idx = 1
         //^dcc raw $_pm.n $gz.popserver TOP $_mail.idx 0
         @ gt.popmode = [subjects]
        }{
         //^dcc raw $_pm.n $gz.popserver QUIT
         @ gt.popmode = [quit]
        }
       }
       (subjects) {
        # do nothing this is the message for num octets in this mail.
       }
       (quit) {
        popdebug Recieved $3-
        gz.mailcleanup;^assign -gt.popmode
       }
       (*) {^hook gzmailerror $*}
      }
     }
     else if ([$3] == [-ERR]) {^hook gzmailerror $*}
     else {
      if (gt.popmode == [subjects]) {
       if (word(3 $*) == [subject:]) {@ _mail[$_mail.idx] #= [ $3-]}
       else if (word(3 $*) == [from:]) {@ _mail[$_mail.idx] #= [$3-]}
       else if (word(3 $*) == [.]) {
        @ _mail.idx++
        if (_mail.idx > gt.mailwaiting) {
         if (gt.newmail) {
          gecho PopMail Subject Gather Complete: Press Alt-L to list subjects
         }
         ^assign -gt.newmail
         //^dcc raw $_pm.n $gz.popserver QUIT
         @ gt.popmode = [quit]
        }{
         //^dcc raw $_pm.n $gz.popserver TOP $_mail.idx 0
        }
       }
      }
      else {^hook gzmailerror $*}
     }
    }
    (*) {if (gt.popmode != [subjects]) {^hook gzmailerror $*}}
   }
  }
 }
}

alias gz.showsubjects {
 if (_mail[1]) {
  for (@ _idx = 1, _idx <= gt.mailwaiting, @ _idx++) {
   gecho $[3]_idx $_mail[$_idx]
  }
 }
}

on #-hook 110 "gznewmail" {
 gz.playsnd newmail
 @ gt.mailerrors = 0
 @ gt.newmail = 1
 if (gz.popsubject) {
  gecho New mail has arrived... \(Total: $gt.mailwaiting message(s)\) \[gathering subjects...\]
 }{
  gecho New mail has arrived... \(Total: $gt.mailwaiting message(s)\)
 }
}

on #-hook 110 "gzmailerror *" {
 @ gt.mailerrors++
 @ gt.mailwaiting = [ERR]
 gecho ERROR: Pop Mail Server ERROR  Check Your Configuration. \($*\)
 gz.mailcleanup
 if (gt.mailerrors >= 5) {
  gecho Received 5 mail errors... Temporarily turning off mail checking.
 }
}

alias gz.mailcleanup {
 //^dcc close raw $_pm.n
 ^assign -_pm.n
 ^on #-dcc_raw 110 -"*"
}

alias gz.domailcheck {
 if (gt.mailerrors < 5 && (gz.popchecking == [ON])) {
  if (gz.popname && gz.poppass && gz.popport && gz.popserver) {
   gz.checkmail
  }{
   gecho Pop Configuration Missing, please configure or Turn off.
  }
 }
}

on #^timer 110 "*" {
 if (gz.popchecking == [ON]) {
  if (gt.mcount >= gz.poptime) {
   gz.domailcheck
   @ gt.mcount = 0
  }{
   @ gt.mcount++
  }
 }
}


alias gz.setemailclient {
 @ _emc.t = [$"Full path Email Client executable  :"]
 if (_emc.t) {
 @ _emc.t = gz.fixpath($_emc.t)
  if (fexist($_emc.t) == 1) {
   @ gz.emailclient = _emc.t
   gecho Email Client executable now $gz.emailclient
   @menucontrol(&setup &200 text Client:    [$gz.emailclient])
   if (fexist($gz.emaildir d) == -1) {gz.setemaildir}
  }{
   gecho Invalid File: $_emc.t
   gz.setemailclient
  }
 }{
  echo Email Client Unchanged.
 }
 purge _emc
}

alias gz.setemaildir {
 @ _emd.t = [$"Working Directory for Email :"]
 if (_emd.t) {
  @ _emd.t = gz.striplastslash($gz.fixpath($_emd.t))
  if (fexist($_emd.t d) == 1) {
   @ gz.emaildir = _emd.t
   gecho Email Working Directory now $gz.emaildir
   @menucontrol(&setup &201 text Working Dir:    [$gz.emaildir])
  }{
   gecho Invalid Directory: $_emd.t
   gz.setemaildir
  }
 }{
  echo Directory Unchanged.
 }
 purge _emd
}

alias gz.setlogdir {
 @ _emd.t = [$"Directory for Logs :"]
 if (_emd.t) {
  @ _emd.t = gz.striplastslash($gz.fixpath($_emd.t))
  if (fexist($_emd.t d) == 1) {
   @ gz.logdir = _emd.t
   gecho Log Directory now $gz.emaildir
   @menucontrol(&setup &204 text Log Dir:    [$gz.logdir])
  }{
   gecho Invalid Directory: $_emd.t
   gz.setlogdir
  }
 }{
  echo Directory Unchanged.
 }
 purge _emd
}


#########################################################################
### figlet v1.0 support by Kanji_Man.  Modified by Gemini
### Modified by OS2-Mike
#   fixed code by OS2-Mike (with a lot of help from mikh)
#   fixored the prob of 4OS2 echoing its logo info into the figlet pipe.
#   filget.exe is borked - it expects a ^Z EOF to terminate it -
#   added to $fig.text
#   Modified slightly by gemini to replace ^Z with $chr(26) :)
#########################################################################
@ def.figfont = [short]
@ fig.fontdir  = [$exedir/figlet.dir]
@ figfont = [$fig.fontdir/short.flf]
alias figfix {
 if ([$0]) {
  @ figfix.count = 0
  ^assign -figfix.text
  while ([$@0-]>=[$figfix.count]) {
   @ figfix.char = [$mid($figfix.count 1 $0-)]
   if ([$strip(<>\;\(\)*/\\\{\}$$~`|'\"
 $figfix.char)]!=[$figfix.char]) {
    @ figfix.text = [$figfix.text\\]
   }
   if (figfix.char) {
    ^assign figfix.text $figfix.text$figfix.char
   }{^assign figfix.text $figfix.text}
  @ figfix.count++
 }
 @ FUNCTION_RETURN = [$encode($figfix.text)]
 purge fixfix
 }{gecho [Error] FIGFIX is an internal alias, avoid using!}
}

alias fig figlet $*
#alias figlist {^exec -name figlet ls $fig.fontdir/*.flf}
alias figlist {
 gecho Starting Font list
 fe ($findfiles(fn $fig.fontdir/*.flf)) _f.1 _f.2 _f.3 _f.4 {
  gecho $[15]_f.1 $[15]_f.2 $[15]_f.3 $[15]_f.4
 }
 gecho End of Font list
 purge _f
}

alias figlet {
 if ([$0]) {
  @ fig.text = encode($strip(|
 $1-)) ## encode($chr(26))
  ^on ^exec_error "figlet *" {gecho [ERROR] Cannot load figlet!}
  if ([$0]==[*]) {^exec -name figlet -out figlet -f $figfont;^msg %figlet $decode($fig.text)
  }{^exec -name figlet -msg $0 figlet -f $figfont;^msg %figlet $decode($fig.text)}
  ^assign -fig.text
 }{gecho Usage: /FIGLET <nick/channel> <text>}
}

alias figfont {
 if ([$0]) {
  @ figfont.file = [$0]
  if ([$fexist($fig.fontdir/$figfont.file\.flf)]==[1]) {
   gecho Figlet font changed from $fig.fontfile\ to $figfont.file\.
   @ figfont = [$fig.fontdir/$figfont.file\.flf]
   @ fig.fontfile = [$figfont.file]
   if ([$1]==[-d]) {@ def.figfont = [$figfont.file];gecho Default Figlet Font Changed}
   ^assign -figfont.file
  }{gecho [Error] Figlet font not found: $figfont.file\}
 }{
  gecho Current Figlet Font: $fig.fontfile\
  gecho Usage: /FIGFONT <fontfile>
 }
}

alias figdir {
 input "Please Enter The directory where you fonts are located: " if ([$0]) {
  if ([$fexist($0-)]==[1]) {
   @ fig.fontdir = [$0-]
   gecho Figlet Font Directory Changed to $fig.fontdir
  }
 }{
  gecho Figlet Font Directory is $fig.fontdir
 }
 figfont $fig.fontfile
}

#Webster Support
^on ^exec_error "spell *" {gecho ERROR loading webster.exe, check that it is in the path}
^on ^exec_error "define *" {gecho ERROR loading webster.exe, check that it is in the path}
^on ^exec "spell *" {if (!match($chr(128) $1-)) {gecho $strip($chr(13)$chr(128) $1-)}}
^on ^exec "define *" {if (!match($chr(128) $1-)) {gecho $strip($chr(13)$chr(128) $1-)}}
alias define {
 if ([$0]) {
  gecho Looking up \$0\\...
  ^exec -name define webster.exe -define $0 @muesli.ai.mit.edu
  wait %define
 }{
  @ _def.me = [$"Enter Word to define : "]
  gecho Looking up \$_def.me\\...
  ^exec -name define webster.exe -define $_def.me @muesli.ai.mit.edu
  wait %define
  ^assign -_def.me
 }
}
alias spell {
 if ([$0]) {
  gecho Checking Spelling of \$0-\\...
  ^exec -name spell webster.exe -spell $0 @muesli.ai.mit.edu
  wait %spell
 }{
  @ _spell.me = [$"Enter Word to define : "]
  gecho Checking Spelling of \$_spell.me\\...
  ^exec -name spell webster.exe -spell $_spell.me @muesli.ai.mit.edu
  wait %spell
  ^assign -_spell.me
 }
}

^set input_prompt ▒▒▒▒▒▒░░░░░░░░░░░░░░35% (Hooks)
##########################
# Client Hooks
^on ^action * {
 if (ischannel($1)) {
  if (isminimized($1)) {gz.bkgd}
  if (match(*$nck.buf* $2-)) {
   gz.playsnd pub
   if ([$showpubtime]==[ON]) {
    xecho -target $1 ${gc.time}<$Z>${cl} $gemz.act ${gc.nickaction}$0${cl} $fix.mirc(${cl} $2-)
   }{
    xecho -target $1 $gemz.act ${gc.nickaction}$0${cl} $fix.mirc(${cl} $2-)
   }
   if (publogging == [ON]) {
    @ publog_cnt++
    @ publog[$publog_cnt] = [$servergroup($lastserver()) $0 $1 $time() $gemz.act ${gc.action}$0${cl} $fix.mirc(${cl} $2-)]
    ^set status_user2 [M:$msglog_cnt/P:$publog_cnt]
   }
  }{
   if (showpubtime == [ON]) {
    xecho -target $1 $gemz.act ${gc.time}<$Z>${cl} ${gc.action}$0${cl} $fix.mirc(${cl} $2-)
   }{
    xecho -target $1 $gemz.act ${gc.action}$0${cl} $fix.mirc(${cl} $2-)
   }
  }
 }{
  if (gz.autotalk && !chanwindow($0) && !winitem($gt.maxwin)) {talk $0 -b}
  if (logging == [ON]) {
   @ msglog_cnt++
   ^set status_user2 [M:$msglog_cnt/P:$publog_cnt]
   @ messagelog[$msglog_cnt] = [\($servergroup($lastserver())\) *\(action\)$0* $fix.mirc({$cl} $2-) <[$Z]:$userhost()>]
   if (USEMSGLOGFILE==[YES]) {
    @ _tmpfile = open($MSGLOGFILE W T)
    @ write($_tmpfile $strip( $messagelog[$msglog_cnt]))
    @ close($_tmpfile)
    ^assign -_tmpfile
   }
  }
  gz.playsnd msg
  if (chanwindow($0) && !ischannel($0)) {
   if (isminimized($0)) {gz.bkgd}
   xecho -level crap -target $0 $gemz.act ${gc.nickaction}$0${cl} $fix.mirc(${cl} $2-)
#   gaecho ${gc.nickaction}$0${cl} $fix.mirc(${cl} $2-)
  }{
   xecho -window Messages $gemz.act \(${gc.action}MSG${cl}\) ${gc.action}$0${cl} $fix.mirc(${cl} $2-)
  }
 }
}

#b#
on ^bad_nick "433 *" {
 if ([$@1] > 8) {
  @ _ns.n = []
  @ _ns.t = [$[1]1]
  fec ($mid(1 9 $1)) _ns.s {@ _ns.n = [$_ns.n]##[$_ns.s]}
  @ _ns.n = [$_ns.n]##[$_ns.t]
  @ new_nick = _ns.n
  purge _ns
 }{@ new_nick = [_$1]}
 gecho Nickname $1 is in use, autochange to $new_nick 
 //nick $new_nick
 ^assign -new_nick
}



#c#

alias gz.sndon {
 if (ctcpsound == [OFF]) {
  @ function_return = 0
 }{
  if (away && gz.noctcpaway) {
   @ function_return = 0
  }{
   @ function_return = isctog($0 S) ? 0 : 1
  }
 }
}

alias gz.reqon {
 if (ctcpsndreq == [OFF]) {
  @ function_return = 0
 }{
  if (away && gz.noctcpaway) {
   @ function_return = 0
  }{
   @ function_return = isctog($0 R) ? 0 : 1
  }
 }
}

on ^ctcp "% % SOUND *" {
    @ _dl = []
    if (rmatch($3 *.wav *.au *.mid) && [$3] && gz.sndon($1)) {
        if (ctcpsnd.havefile($3)) {
          mmpm.playfile2 $gz.playifplaying $ctcpsnd.fname
#          mmpm.playfile $ctcpsnd.fname
        }{
            if (!gz.reqon($1)) @ _dl = [autorequest disabled]
            else if (ctcpsnd.isgetting($3)) @ _dl = [downloading]
            else if (ctcpsnd.isrequested($3) < 30) @ _dl = [requested]
            else {
        if (gz.mircsndpatch) {
                    //^quote PRIVMSG $1 :!$0 $3
                }{
                    //^quote PRIVMSG $0 :!$0 $3
                }
                ctcpsnd.requested $3
                @ _dl = [requesting]
            }
        }
        if (ischannel($1)) {
            /xecho -t $1 $gemz.act ${gc.nickaction}$0${cl} SOUND: $file.sanspath($3) ${_dl?[\($_dl\)]:[]} $mirc2cntl( $4-)
        }{
            /xecho >$gemz.act ${gc.nickaction}$0${cl} SOUND: $file.sanspath($3) ${_dl?[\($_dl\)]:[]} $mirc2cntl( $4-)
        }
    }{
        if (ischannel($1)) {
            /xecho -t $1 $gemz.act ${gc.nickaction}$0${cl} SOUND: $file.sanspath($3) \(ctcp sounds disabled\) $mirc2cntl( $4-)
        }{
            /xecho >$gemz.act ${gc.nickaction}$0${cl} SOUND: $file.sanspath($3) \(ctcp sounds disabled) $mirc2cntl( $4-)
        }
    }
}

on ^hook "ctcpsnd received %*" {
 if (ctcpsound == [on]) {
  gecho Requested Sound Finished: $2-
  /mmpm.playfile2 $gz.playifplaying $2
# /mmpm.playfile $2
 }
}

on ^hook "ctcpsnd request % % *" {
 gecho \($4\) file request from $3 ${[$2]?[sent]:[access denied]}
}

alias sound {
 if ([$0]) {
  if (T) {
   if (ischannel($T)) {@ _t = T}{@ _t = strip(= $T)}
   if (ctcpsnd.localfile($0)) {
    /mmpm.playfile2 $gz.playifplaying $ctcpsnd.fname
#   /mmpm.playfile $ctcpsnd.fname
    /ctcp $_t SOUND $0-
    if ([$1] != []) {
     //xecho -t $T $gemz.act ${gc.action}$N${cl} SOUND \($0\): $1-
    }{
     //xecho -t $T $gemz.act ${gc.action}$N${cl} SOUND \($0\)
    }
   }{
    gecho File $0 does not exist${index(\\/: $0) >= 0 ? [, please check your /set sound_path] : []}
   }
  }{
   gecho There are no channel or /query in this window
  }
 }{
  gecho Usage: /sound file.wav [</me like action>]
 }
 ^assign -_t
}

alias csound {
 if (ctcpsnd.localfile($1)) {
  /mmpm.playfile2 $gz.playifplaying $ctcpsnd.fname
# /mmpm.playfile $ctcpsnd.fname
  /ctcp $0 SOUND $1-
  //xecho -t $0 $gemz.act ${gc.action}$N${cl} SOUND \($1)
 }{
  gecho File $1 does not exist
 }
}

### if autorequest is disabled, user still can do !nick file.wav etc manually
### we should catch these and prepare to receive file, uses numeric 74

on #-send_msg 74 "% !% %.wav" ctcpsnd.request $2
on #-send_msg 74 "% !%.au" ctcpsnd.request $2
on #-send_msg 74 "% !%.mid" ctcpsnd.request $2

on #-send_notice 74 "% !% %.wav" ctcpsnd.request $2
on #-send_notice 74 "% !% %.au" ctcpsnd.request $2
on #-send_notice 74 "% !% %.mid" ctcpsnd.request $2

on #-send_public 74 "% !% %.wav" ctcpsnd.request $2
on #-send_notice 74 "% !% %.mid" ctcpsnd.request $2
on #-send_msg 74 "% !% %.au" ctcpsnd.request $2

^on -ctcp "% % VER%" {
 gz.setvers
 ctcpreq $*
}
^on -ctcp "% % PING *" {ctcpreq $*}
^on -ctcp "% % FINGER*" {ctcpreq $*}
^on -ctcp "% % USERINFO*" {ctcpreq $*}
^on -ctcp "% % CLIENTINFO*" {ctcpreq $*}
^on ^ctcp_reply "% FINGER *" {ctcpreply $*}
^on ^ctcp_reply "% USERINFO *" {ctcpreply $0 USERINFO $2-}
^on ^ctcp_reply "% TIME *" {ctcpreply $*}
# for version detection, put a 4 char word for the script version (to make it look clean)
^on ^ctcp_reply "% VERSION *" {verreply ???? $*}
^on ^ctcp_reply "% VERSION *gem*" {verreply GemZ $*;@ gemzusers++}
^on ^ctcp_reply "% VERSION *SrFrog*" {verreply LiCe $*}
^on ^ctcp_reply "% VERSION *Kanj*" {verreply KMP_ $*}
^on ^ctcp_reply "% VERSION *gamm*" {verreply Gama $*}
^on ^ctcp_reply "% VERSION *AtlantiS*" {verreply Atla $*}
^on ^ctcp_reply "% VERSION *PM IRC*" {verreply PMIR $*}
^on ^ctcp_reply "% VERSION *mIRC32*" {verreply mIRC $*}
^on ^ctcp_reply "% VERSION *mIRC16*" {verreply mIRC $*}
^on ^ctcp_reply "% VERSION *ScrollZ*" {verreply _sz_ $*}
^on ^ctcp_reply "% VERSION *BitchX*" {verreply bchX $*}
^on ^ctcp_reply "% VERSION *PIRCH32*" {verreply prch $*}
^on ^ctcp_reply "% VERSION *CtoolZ*" {verreply CtlZ $*}
^on ^ctcp_reply "% VERSION *:OpenChat/2 OS/2 PM*" {verreply OCHT $*}

alias verreply if ([$0]) {if ([$ctcpvers]==[ON]) {gecho ${gc.ctcpban}ctcp${cl}: ${gc.ctcp}$tolower($2) reply${cl} [$0\] from ${gc.ctcpnk}$1${cl}: $3-}{ctcpreply $1-}}
^on ^ctcp_reply "% PING *" {
 @ ctcp_replytmp = time() - [$2]
 gecho ${gc.ctcpban}ctcp${cl}: ${gc.ctcp}$tolower($1) reply${cl} from ${gc.ctcpnk}$0${cl}: $tdiff($ctcp_replytmp)
 ^assign -ctcp_replytmp
}
^on ^channel_synch "*" {gecho your join to channel $0\ is now synched${cl} \($1\ seconds\)}
^on ^channel_signoff "*" {
 ndljoin $0 $1
 if (isminimized($0)) {gz.bkgd}
 if (!match($0 $lchanlist)) {
  gz.secho quit $0 Signoff for ${gc.sign}$1${cl} in ${gc.sign}$0${cl}: ${gc.peren}\(${cl}$fix.mirc(${cl} $2-)${gc.peren}\)${cl} $timestamp()
 }
}
^on ^channel_signoff "% % %.% %.%" {
 if (isminimized($0)) {gz.bkgd}
 ndljoin $0 $1
 if (isbogus($1-)) {
  gz.secho quit $0 Signoff for ${gc.sign}$1${cl} in ${gc.sign}$0${cl} ${gc.peren}\(${cl}$2-${gc.peren}\)${cl}
 }{
  ^netbroke $encode($tolower($0)) $encode($1) $encode($2).$encode($3) $2 $3
 }
}
^on ^channel_signoff "* * Killed (*)" {
 if (isminimized($0)) {gz.bkgd}
 ndljoin $0 $1
 if (rmatch($strip(\( $3-) %.*)) {
  gecho ${gc.kill}$1 was collided${cl}: $3-
 }{
  gecho ${gc.kill}Operator Kill${cl}: ${gc.killnk}$strip(\( $3)${cl} killed ${gc.killnk}$1${cl} ${gc.peren}\(${cl}$strip(\(\) $4-)${gc.peren}\)${cl}
 }
}

### check server in servers menu when connected

on #-connect 2222 * {
 @ serverdata($lastserver() 1 $servergroup($lastserver()))
 @menucontrol(&srv &${lastserver()+1} check 1)
 @menucontrol(&srv &${lastserver()+100} check 1)
}

### check server in servers menu when disconnected

on #-server_closed 2222 "*" {
 @menucontrol(&srv &${[$0]+1} check 0)
 @menucontrol(&srv &${[$0]+100} check 0)
}

on #-server_changed 2222 "*" {makesrvmenu}

^set input_prompt ▒▒▒▒▒▒░░░░░░░░░░░░░░36% (Hooks)
#d#
^on ^dcc_chat * {
 if (isminimized(=$0)) {gz.bkgd}
 gz.playsnd chat
 echo =${gc.dcc}$0${cl}= $fix.mirc(${cl} $1-)
}

^on ^dcc_chat "% 
ACTION *" {
 if (isminimized(=$0)) {gz.bkgd}
 gz.playsnd chat
 echo = * ${gc.dcc}$0${cl}= $fix.mirc(${cl} $2-)
}

^on ^dcc_chat "% 
ACTION *
" {
 if (isminimized(=$0)) {gz.bkgd}
 gz.playsnd chat
 echo = * ${gc.dcc}$0${cl}= $fix.mirc(${cl} $left(${[$@2-]-1} $2-))
}

### send /me thru dcc chats

^on ^input "/me *" {
 if (left(1 $T) == [=]) {//^msg $T 
ACTION $1-\
}
 else //sendline $*
}

^on ^dcc_lost "% % chat chat*" {
 if (chanwindow(=$1) >= 0) {
  @ _dc.l = [=]##[$1]##[_Queried]
  xecho -window $_dc.l $gemz [gxdcc] DCC CHAT to ${gc.dcc}$1 ${gc.errortopic}$4${cl}
  xecho -window $_dc.l $gemz [gxdcc] Press alt-F4 in this window to close window.
 }{
  gecho $gx DCC CHAT to ${gc.dcc}$1 ${gc.errortopic}$4${cl}
 }
}
#e#
#f#
#g#
#h#
#i#
^on ^idle * {
 if ((gz.awaytime) && (gz.awaytime <= [$0]) && (!away)) {
# if ([$0]==[$gz.awaytime]&&[$gz.awaytime]!=[0]&&[$away]!=[1]) {
  if (gz.qaaway) {
   away -q $str.autoaway [$gz.awaytime min]
  }{
   away -n $str.autoaway [$gz.awaytime min]
  }
}}

^on ^invite * {
 if (ischannel($1)) {
  @ gemz.linvite = [$1]
  if ([$isajoin($1)]==[1]) {
   if (!onchannel($N $1)) {
    gecho AutoJoining $1 on invite from $0
    @ _gonna_join($1 0)
    //QUOTE JOIN $1 $ajkeys[$%1]
   }
  }{
   for (@idx = 1, (idx <= _udb.cnt && !_imatch), @idx++) {@ _imatch = [$rmatch($0!$userhost() $_udb[$idx][mask])]}
   if (index(AFIOPMNBV $_udb[$_imatch][flags]) >= 0 && [$ajoinfriends]==[YES]) {
    gecho AutoJoining $1 on invite from Friend: $0
    @ _gonna_join($1 0)
    //QUOTE JOIN $1 $ajkeys[$%1]
   }{gecho Invite to $1 from $0 Press Ctrl-K to join}
   ^assign -_imatch;^assign -idx
  }
 }{gecho Fake invite to $1 from $0}
}

alias _win.waiting {
 @ function_return = 0
 for (@ _ww.idx = 0, _ww.win = winitem($_ww.idx), @ _ww.idx++) {
  if (word(2 $_ww.win) == lastserver() && word(3 $_ww.win) == [<none>] && word(5 $_ww.win) == [$0]) {
   @ function_return = word(0 $_ww.win)
   //break
  }
 }
 purge _ww
}
#j#
^on ^join_me * {
 synch $0 2
 # check if no users on a channel, that mean we joined and created a channel
 if (!chanusers($0)) {_delayop_channel2 $0}
}
on #-join_me 131 * {
 if ([$(chlog[$%0][stat])]==[ON]) {winlog ON $0 $(chlog[$%0][logfile])}
 foreach ch.cset.$%0 _c.c {//^cset $0 $_c.c $ch.cset[$%0][$_c.c]}
 if (_c.r = chanwindow($0)) {if (word(6 $winitem(%$_c.r)) == [<none>]) {makemenubar}}
 purge _c
}
##############
alias _addljoin {
 for (@ nc.2 = 10, nc.2 > 1, @ nc.2--) {
  @ nc.1 = nc.2 - 1
  @ lastjoin[$%1][$nc.2] = lastjoin[$%1][$nc.1]
 }
 @ lastjoin[$%1][1] = [$0]
 purge nc
}


alias ndljoin {
 @ _idx = 1
 for (@ idx = 1, idx <= 10, @ idx++) {
  if ([$1] != [$lastjoin[$%0][$idx]]) {
   @ _lastjoin[$%0][$_idx] = lastjoin[$%0][$idx]
   @ _idx++
   @ didbob = 1
  }
 }
 if (didbob) {
  purge lastjoin[$%0]
  for (@ idx = 1, idx <= 10, @ idx++) {@ lastjoin[$%0][$idx] = _lastjoin[$%0][$idx]}
 }
 purge _lastjoin
 ^assign -_idx
 ^assign -didbob
 ^assign -idx
}

alias ncljoin {for (@ idx = 1, idx <= 10, @ idx++) {if ([$lastjoin[$%0][$idx]]==[$1]) {@ lastjoin[$%0][$idx] = [$2]}}}

alias gz.lastw {@ function_return = word(${rmatch($* *)-1} $*)}
alias last {@ function_return = gz.lastw($*)}

alias lastjoin {
 if (C) {
  if (lastjoin[$%C][1]) {
   gecho Last (10) Joins for $C
   for (@idx = 1, idx <= 10, @ idx++) {
    if (lastjoin[$%C][$idx]) {
     gecho [$[2]idx\]: $[10]lastjoin[$%C][$idx] \($nickdata($C $lastjoin[$%C][$idx] 0)\)
    }
   }
   gecho End of List
  }{gecho Lastjoin List is empty (no joins since your own join)}
 }{gecho you are not in a channel}
}

alias ljk {
 if (C) {
  if (lastjoin[$%C][1]) {
   if (ischanop($N $C)) {
    if ([$0]) {
     if (lastjoin[$%C][$0]) {
      //kick $C $lastjoin[$%C][$0] Lastjoin Kick [$0]
     }{
      gecho Lastjoin index: $0 does not exist
     }
    }{
     //kick $C $lastjoin[$%C][1] Lastjoin Kick
    }
   }{gecho You are not opped}
  }{gecho No Last Join}
 }{gecho No channel}
}

^on ^join "*" {
 if (isminimized($1)) {gz.bkgd}
 if ([$0]!=[$N]) {_addljoin $0 $1}{purge lastjoin[$%0]}
 ^netjoined $encode($tolower($1)) $encode($0) $1 $0 $userhost()
}

# whoooa, our own //join command in scripting :)
^on ^join_cmd * {
 if (![$0]) {
 # list channels
  for (@jc.idx = 0, servername($jc.idx), @jc.idx++) {
   if (isconnected($jc.idx)) {
    /gecho Server $servername($jc.idx):$serverport($jc.idx) \($servernick($jc.idx)\)
    /gecho Channels: $_srvchans($jc.idx)
   }
  }
 }{
  if ([$0] == [-invite]) {
   if (I) {
    //join $I
   }{
    gecho You have not been invited to any channel yet
   }
  }{
   @ jc.ch = ischannel($0) ? [$0] : [#$0]
   if (onchannel($N $jc.ch) && chanwindow($jc.ch)) {
    //window show $chanwindow($jc.ch)
   }{
    if (onchannel($N $jc.ch)) {
     @ jc.w = _gonna_join($jc.ch 1)
     //window $jc.w channel $jc.ch
    }{
     @ jc.w = _win.waiting($jc.ch)
     if (jc.w) {
      //quote JOIN $jc.ch $1
      //window show $jc.w
     }{
      @ jc.w = _gonna_join($jc.ch 1)
      //quote JOIN $jc.ch $1
     }
    }
   }
  }
 }
 purge jc
}
on ^join_before * {
 @ _r = _gonna_join($0 1)
 # need to insert code here wich will create window's _r menu according to
 # channel settings in $ch.flags and stored channel flood prot settings in
 # $ch.flood. We cannot do /cset's here because channel not created yet,
 # csets will be done from on -join_me
 //^assign -_r
}


# $0 == channel, returns window refnum of a window wich is waiting for that
# channel and 0 if not founb

alias _win.waiting {
 @ function_return = 0
 for (@ _ww.idx = 0, _ww.win = winitem($_ww.idx), @ _ww.idx++) {
  if (word(2 $_ww.win) == lastserver() && word(3 $_ww.win) == [<none>] && word(5 $_ww.win) == [$0]) {
   @ function_return = word(0 $_ww.win)
   //break
  }
 }
 purge _ww
}

# $0 -- channel we gonna join, $1 == 1 if we want window to be in foreground
# and 0 if we want new window created in background
# returns refnum of a window that channel gonna go

alias gz.usenklist {
 if (ch[nl][$%0] == [ON]) {@ function_return = [n]}
 else if (ch[nl][$%0] == [OFF]) {@ function_return = []}
 else if (gz.nicklist) {@ function_return = [n]}
}


alias _gonna_join {
 @ jb.found = _win.waiting($0)
# only if not found search for free window wich is not status window and
# not list window, and dosnt have /query
 if (!jb.found) {
  for (@ jb.idx = 0, jb.win = winitem($jb.idx), @ jb.idx++) {
   if (word(2 $jb.win) == lastserver() && word(3 $jb.win) == [<none>]  && \
   word(4 $jb.win) == [<none>] && word(5 $jb.win) == [<none>] && \
   word(1 $jb.win) != [messages] && word(1 $jb.win) != [OperView] && word(1 $jb.win) != [xdcc] && \
   word(0 $jb.win) != status_wnd && word(0 $jb.win) != chanlist_wnd) {
   @ jb.found = 1
   //break
            }
        }

# if we found such window, assign waiting channel to it, and show it if
# minimized, otherways create new window...

        if (jb.found) {
            if ([$ch.winsizepos[$%0]]!=[]) {
                //window $word(0 $jb.win) waiting_channel $0 setwindowpos sp $ref(2-5 $ch.winsizepos[$%0]) font $word(0 $ch.winsizepos[$%0])
            }{
                //window $word(0 $jb.win) waiting_channel $0 setwindowpos sp $ref(2-5 $gzdefault.pos) font $default_font
            }
      if (ch.codepage[$%0]) {//window $word(0 $jb.win) codepage $ch.codepage[$%0]}{//window $word(0 $jb.win) codepage $default_codepage}
            if (gz.usenklist($0)) {
                //^window $word(0 $jb.win) NICKLIST ON
            }{
                //^window $word(0 $jb.win) NICKLIST OFF
            }
            #recreate_channel_menu $0
            //window $word(0 $jb.win) menu menubar
            if ([$1]) {
                //window show $word(0 $jb.win)
            }
            @ function_return = word(0 $jb.win)
        }{
      gz.playsnd wopen
            #recreate_channel_menu $0
      @_oldcp = default_codepage
      if (ch.codepage[$%0]) {
       //^set default_codepage $ch.codepage[$%0]
      }
            if ([$ch.winsizepos[$%0]]!=[]) {
                @ jb.ref = newwindow(1 $1 $word(0 $ch.winsizepos[$%0]) menubar 0 $ref(2-5 $ch.winsizepos[$%0]) $gz.usenklist($0))
           }{
                @ jb.ref = newwindow(1 $1 -1 menubar 0 $ref(2-5 $gzdefault.pos) $gz.usenklist($0))
            }
      if (ch.codepage[$%0]) {
       //window $jb.ref codepage $default_codepage
      }
            //window $jb.ref waiting_channel $0 menu menubar
            @ function_return = jb.ref
      ^set default_codepage $_oldcp
      ^assign -_oldcp
        }
    }{
        @ function_return = word(0 $jb.win)
    }
    purge jb
}

# $0 == server num, returns space separated list of channels

alias _srvchans {evalserver $0 {@ function_return = mychannels()}}

^set input_prompt ▒▒▒▒▒▒░░░░░░░░░░░░░░37% (Hooks)
#k#
on ^kick "*" {
 ndljoin $2 $0
#modified to use mikh's new userlist
 if ([$0]==[$N]) {
  if ([$1]==[$N]) {gz.playsnd mekick}{gz.playsnd youkick}
  ^hook gzkickme $2 $1
  gz.secho kick $2 You were kicked from ${gc.kickc}$2${cl} by ${gc.kickn}$1${cl} ${gc.peren}\(${cl}$fix.mirc(${cl} $3-)${gc.peren}\)${cl} $timestamp()
  if (gz.autorejoin) {
   //quote join $2 $key($2)
  }
 }{
  if (!match($2 $lchanlist)) {
   if ([$1]==[$N]) {gz.playsnd mekick;^hook gzmekick $2 $1}{gz.playsnd kick;^hook gzkick $2 $1}
   gz.secho kick $2 ${gc.kicked}$0${cl} was kicked from ${gc.kickc}$2${cl} by ${gc.kickn}$1${cl} ${gc.peren}\(${cl}$fix.mirc(${cl} $3-)${gc.peren}\)${cl} $timestamp()
  }
  if (ischanop($N $2) && index(i $chanmode($2)) >= 0 && index(IP $nickdata($2 $0 2)) >= 0) {//invite $0 $2}
  if ([$1]!=[$N]) {
   if (ischanop($N $2) && index(R $nickdata($2 $0 2)) >= 0) {
    if (index(AFILROPBV $nickdata($2 $1 2)) >= 0) {
    }{
     //mode $2 -o+b $1 $gz.nban($1 $uh($1))
     //kick $2 $1 Pertekt: $0
    }
}}}}

alias timestamp {@ function_return = gz.timestamps ? [\[${gc.time}$Z${cl}\]] : []}

#l#
^on ^leave * {
 if (isminimized($1)) {gz.bkgd}
 if ([$0]==[$N]) {purge lastjoin.$encode($1)}{ndljoin $1 $0}
 if (!match($1 $lchanlist)) {gz.secho part $1 ${gc.left}$0${cl} has left channel ${gc.left}$1${cl} $timestamp()}
}
#m#
^on ^msg * if (!ctcpsnd.msg($*)) {
 @ gt.maxwin = gz.maxwins - 1
 if (gz.autotalk && !chanwindow($0) && !winitem($gt.maxwin)) {talk $0 -b}
 gz.playsnd msg
 if (msgbeeps==[ON]) {//beep}
 if (chanwindow($0) && !ischannel($0)) {
  if (isminimized($0)) {gz.bkgd}
  if (showmsgtime==[ON]) {
   evalserver $lastserver() {xecho -target $0 ${gc.msgbrac}<${gc.msg}$0${gc.msgbrac}>${cl} [${gc.time}$Z${cl}] $fix.mirc(${cl} $1-)}
  }{
   evalserver $lastserver() {xecho -target $0 ${gc.msgbrac}<${gc.msg}$0${gc.msgbrac}>${cl} $fix.mirc(${cl} $1-)}
  }
 }{
  if (gemz.long==[ON]) {
   if (showmsgtime==[ON]) {
    echo ${gc.msgbrac}\[${gc.msg}$0${gc.msgbrac}:${gc.msguh}${gc.msg}$userhost()${gc.msgbrac}\] ${gc.time}<$Z>${cl} $fix.mirc(${cl} $1- )
   }{
    echo ${gc.msgbrac}\[${gc.msg}$0${gc.msgbrac}:${gc.msguh}${gc.msg}$userhost()${gc.msgbrac}\]${cl} $fix.mirc(${cl} $1-)
   }
  }{
   if (showmsgtime==[ON]) {
    echo ${gc.msgbrac}\[${gc.msg}$0${gc.msgbrac}\]${cl} ${gc.time}<$Z>${cl} $fix.mirc(${cl} $1-)
   }{
    echo ${gc.msgbrac}\[${gc.msg}$0${gc.msgbrac}\]${cl} $fix.mirc(${cl} $1-)
   }
  }
 }
 if ((rmatch($0 $tk.msglist) == 0) && (last.mesg.from != [$0])) {
  if (away) {
   ^notice $0 I am away.  Message logging is \$logging\. <gz>
  }
 }
 if (logging == [ON]) {
  @ msglog_cnt++
  ^set status_user2 [M:$msglog_cnt/P:$publog_cnt]
  @ messagelog[$msglog_cnt] = [\($servergroup($lastserver())\) *$0* $fix.mirc({$cl} $1-) <[$Z]:$userhost()>]
  if (USEMSGLOGFILE==[YES]) {
   @ _tmpfile = open($MSGLOGFILE W T)
   @ write($_tmpfile $strip( $messagelog[$msglog_cnt]))
   @ close($_tmpfile)
   ^assign -_tmpfile
  }
 }
 /addtolastmsg $0 $1-
 @ last.mesg = [*$0* $1-]
 @ last.mesg.from = [$0]
}

alias addtolastmsg {
 for (@ lm.2 = gz.maxrelms, lm.2 > 1, @ lm.2--) {
  @ lm.1 = lm.2 - 1
  @ lastmsg[$lm.2] = lastmsg[$lm.1]
 }
 @ lastmsg.1 = [*$0* $1-]
 purge lm
}

alias relm {
 if ([$0]) {
  if ([$left(1 $0)]==[-]) {
   if ([$1]) {
    if (lastmsg[$strip(- $0)]) {msg $1 $lastmsg[$strip(- $0)]}
   }{
    if (lastmsg[$strip(- $0)]) {send $lastmsg[$strip(- $0)]}
   }
  }{msg $0 $lastmsg.1}
 }{send $lastmsg.1}
}

on ^mode * {
 if (isminimized($1)) {gz.bkgd}
 if ([$1]==N) {
  gecho ${gc.mode}Mode change${cl} \'$ansi2c($2-)\' by ${gc.modenk}$0${cl}
 }{
  if (index(. $0) == -1) {
   if (isctog($1 Z)) {
#currently only single modes will be compressed.
    if (ischanop($3 $1) && ([$2] == [+o])) {}
    else if (!ischanop($3 $1) && ([$2] == [-o])) {}
    else if (isvoice($3 $1) && ([$2] == [+v])) {}
    else if (!isvoice($3 $1) && ([$2] == [-v])) {}
    else {gz.secho mode $1 ${gc.mode}Mode change${cl} \'$ansi2c($2-)\' on ${gc.mode}$1 ${cl}by ${gc.modenk}$0${cl}}
   }{
    gz.secho mode $1 ${gc.mode}Mode change${cl} \'$ansi2c($2-)\' on ${gc.mode}$1 ${cl}by ${gc.modenk}$0${cl}
   }
  }{
   gz.secho mode $1 ${gc.modehack}Mode hack${cl} \'$ansi2c($2-)\' on ${gc.mode}$1 ${cl}by ${gc.modenk}$0${cl}
  }
 }
}

#n#
^on ^nickname "*" {
 if (chanwindow($0)) {
  xecho -target $0 $gemz Nick Change Detected: $0 -> $1 (window modified)
  //window $chanwindow($0) name $1_Queried;//window $chanwindow($0) query $1
 }
 if (decode($pubreplynick) == [$0]) {@ pubreplynick = encode($1)}
 fe ($tk.msglist) _tknick {
  if ([$_tknick]==[$0]) {@ _tknick = [$1]}
  if (tmp.tklist) {@ tmp.tklist = [$tmp.tklist $_tknick]}{@ tmp.tklist = [$_tknick]}
 }
 @ tk.msglist = tmp.tklist
 ^assign -tmp.tklist;^assign -_tknick
 fe ($mychannels()) _tmpchan {
  if (match($0 $chanusers($_tmpchan)) >= 1) {
   if (isminimized($_tmpchan)) {gz.bkgd}
   xecho -target $_tmpchan $gemz ${gc.nickchg}$0${cl} is now known as ${gc.nickchg}$1${cl}
   ncljoin $_tmpchan $0 $1
  }
 }
 ^assign -_tmpchan;^assign -_tknick;^assign -_tmpchan
}

^on ^notify_signon "*" {
 gz.playsnd notify
 if ([$1]) {
  gecho ${gc.notify}SIGNON${cl}: ${gc.time}<$Z>${cl} ${gc.notify}$0 ${gc.peren}\(${cl}$1@$2${gc.peren}\)${cl}
  _notify_uh $0 $1@$2
 }{
  if (uh($0)) {
   gecho ${gc.notify}SIGNON${cl}: ${gc.time}<$Z>${cl} ${gc.nofity}$0 ${gc.peren}\(${cl}$uh($0)${gc.peren}\)${cl}
   _notify_uh $0 $uh($0)
  }{
   userhost $0 -cmd if ([$3]!=[<UNKNOWN>]) {
    _notify_uh $0 $3@$4
    gecho ${gc.notify}SIGNON${cl}: ${gc.time}<$Z>${cl} ${gc.nofity}$0 ${gc.peren}\(${cl}$3@$4${gc.peren}\)${cl}
   }{
    gecho ${gc.notify}SIGNON${cl}: ${gc.time}<$Z>${cl} ${gc.notify}$0 ${cl}
   }
  }
 }
}

^on ^notify_signoff "*" {
 ^hook gzsignoff $*
 gz.playsnd notifyoff
 if ([$1]) {
  gecho ${gc.notify}SIGNOFF${cl}: ${gc.time}<$Z>${cl} ${gc.notify}$0 ${gc.paren}\(${cl}$1@$2${gc.paren}\)${cl}
 }{
  gecho ${gc.notify}SIGNOFF${cl}: ${gc.time}<$Z>${cl} ${gc.notify}$0 ${cl}
 }
}

^on ^notice * if (!ctcpsnd.notice($*)) {
 @ wallchan = _chan($1)
 if (wallchan) {
  xecho -target $wallchan ${cl}-${gc.notice}$0${cl}- $fix.mirc(${cl} $1-)
 }{echo -${gc.notice}$0${cl}- $fix.mirc(${cl} $1-)}
 @ last.noti = [-$0\- $1- <[$Z]:$userhost()>]
 @ last.note.from = [$0]
 ^assign -wallchan
}

^on ^notice "% INVITE: #% (% invited % [%])" {
 gecho $5 $6 was invited by $4
}

^on ^public_notice * {
 echo \-${gc.notice}$0${cl}:${gc.notice}$1${cl}\- $fix.mirc(${cl} $2-)
}
#o#
alias _dropsend {
 fe ($2-) _sendfile {
  if (gx.sendcount() < gx.maxsends) {
   //dcc $0 $1 "$decode($_sendfile)"
  }{
   gecho Max Sends Reached... Queuing file: $decode($_sendfile)
   xdcc.qfileadd $lastserver() $1 $0 "$decode($_sendfile)"
  }
 }^assign -_sendfile
}

^on ^objects_dropped "% % % COPY*" {
 if ([$8] && lastclickline(4) && onchannel($lastclickline(4) $1)) {
  if ([$right(4 $decode($8))]==[.kix] || [$right(2 $decode($8))]==[.k]) {
   if (ischanop($N $1)) {
    //KICK $1 $lastclickline(4) $randread("$decode($8)") [DropKick]
   }{gecho Yer Not Opped.. Drop a Brick On yer head!}
  }{gecho CONTROL-Drops are only used for .kix files}
 }{gecho CONTROL-Drops for .kix files must be dropped on a nick}
}

^on ^objects_dropped "% % % MOVE*" {
#gecho $0-
#gecho $decode($8)
gecho SHIFT-DROPS are Not Implented Yet.
}

^on ^objects_dropped "% % % LINK*" {
 if (([$8]) && (lastclickline(4) == N)) {
  fe ($8-) __of.f {
   @ __of.fx = __of.fx ## [ $decode($__of.f)]
  }
  @ __of.a = [$"Do you want to setup an offer for Dragged files? [Y/n] : "]
  if (__of.a != [n]) {
   xdcc.offer $__of.fx
  }
  purge __of
 }{
  if ([$8] && lastclickline(4) && (onchannel($lastclickline(4) $1) || lastclickline(4) == T )) {
   if ([$right(4 $decode($8))]==[.kix] || [$right(2 $decode($8))]==[.k]) {
    if (ischanop($N $1)) {
     //KICK $1 $lastclickline(4) $randread("$decode($8)") [DropKick]
    }{gecho Yer Not Opped.. Drop a Brick On yer head!}
   }{
    menu -tempmenu
    menu tempmenu
    if ([$9]) {
     menuitem tempmenu "Send Files to $lastclickline(4)" /_dropsend send $lastclickline(4) $8-
     menuitem tempmenu "Resend Files to $lastclickline(4)" /_dropsend resend $lastclickline(4) $8-
    }{
     if ([$fexist("$decode($8)" d)]==[1]) {
      menuitem tempmenu "Send Contents of folder to $lastclickline(4)" /_dropsend send $lastclickline(4) $findfiles(e "$decode($8)/*")
      menuitem tempmenu "Resend Contents of folder to $lastclickline(4)" /_dropsend resend $lastclickline(4) $findfiles(e "$decode($8)/*")
     }{
      menuitem tempmenu "Send $decode($8) to $lastclickline(4)" _dropsend send $lastclickline(4) $8
      menuitem tempmenu "ReSend $decode($8) to $lastclickline(4)" _dropsend resend $lastclickline(4) $8

     }
    }
    /popupmenu -window $0 tempmenu
    #^assign -blek
   }
  }{
   # show a window so prompt appears in it and not in current one
   //window show $0
   if ([$fexist("$decode($8-)" d)]==[1]) {
    if ((bah = [$"Send Contents of folder to whom?: "]) != []) {
     fe ($findfiles(e "$decode($8)/*")) _tmpsend {
      gz.exdcc send $bah $_tmpsend
     }
    }
   }{
    if ((bah = [$"Send file(s) to whom?: "]) != []) {
     fe ($8-) _tmpsend {
      gz.exdcc send $bah $_tmpsend
     }

    }
   }
  }
 }
 ^assign -_tmpsend
 ^assign -bah
}
#p#

on #-public 67 "*" {@ wilp[$%1] = [$0]}
alias wilp {
 if (C) {
  if (wilp[$%C]) {
   gecho Checking whois on Last public in $C \($wilp[$%C]\)
   /wi $wilp[$%C]
  }{gecho No Last public to check}
 }{gecho No Channel}
}

^on ^public * if (!ctcpsnd.public($*)) {
 if (isminimized($1)) {gz.bkgd}
 if (match(*$nck.buf* $2-)) {
  @ pubreplynick = encode($0)
  gz.playsnd pub
  if (showpubtime == [ON]) {
   xecho -target $1 ${gc.time}<$Z>${cl} ${gc.pubbrac}<${gc.nickpubmsg}$0${gc.pubbrac}>${cl} $fix.mirc(${cl} $2-)
  }{
   xecho -target $1 ${gc.pubbrac}<${gc.nickpubmsg}$0${gc.pubbrac}>${cl} $fix.mirc(${cl} $2-)
  }
  if (publogging == [ON]) {
   @ publog_cnt++
   @ publog[$publog_cnt] = [$servergroup($lastserver()) $0 $1 $time() $fix.mirc(${cl} $2-)]
   ^set status_user2 [M:$msglog_cnt/P:$publog_cnt]
  }
 }
 else if (_testhilite($2-)) {
  if (gz.loghilites) {
   @ publog_cnt++
   @ publog[$publog_cnt] = [$servergroup($lastserver()) $0 $1 $time() $fix.mirc(${cl} $2-)]
   ^set status_user2 [M:$msglog_cnt/P:$publog_cnt]
  }
  gz.playsnd hilitelist
  if ([$showpubtime]==[ON]) {
   xecho -target $1 ${gc.time}<$Z>${cl} ${gc.pubbrac}<${gc.hilitepubmsg}$0${gc.pubbrac}>${cl} $fix.mirc(${cl} $2-)
  }{
   xecho -target $1 ${gc.pubbrac}<${gc.hilitepubmsg}$0${gc.pubbrac}>${cl} $fix.mirc(${cl} $2-)
  }
 }
 else {
  if (showpubtime == [ON]) {
   xecho -target $1 ${gc.time}<$Z>${cl} ${gc.pubbrac}<${gc.pubmsg}$0${gc.pubbrac}>${cl} $fix.mirc(${cl} $2-)
  }{
   xecho -target $1 ${gc.pubbrac}<${gc.pubmsg}$0${gc.pubbrac}>${cl} $fix.mirc(${cl} $2-)
  }
 }
}

#r#

### lag meter per server, uses serverdata(server 0) and %0 status item on
### a status bar, all lag meter events are using numeric 11

on #-timer 11 * {
 for (@_srv=0,servername($_srv)!=[],@_srv++) {
  if (serverdata($_srv 0) != [<=L=>]) @serverdata($_srv 0 <=L=>)
  if (isconnected($_srv) && !lastlag[$_srv]) {
    @_lagtime = time()
    //evalserver $_srv {//quote PING $_lagtime $S}
    @lastlag[$_srv] = _lagtime
  }
 }
}

on #-server_closed 11 * {
    @serverdata($0 0 <=L=>)
    if ([$0] != -1) @lastlag[$0] = 0
}

#on #-server_changed 11 "new %" {@serverdata($1 0 <=L=>)}

on ^pong "*.* %" {
 if ([$0] == S) {
    if (isdigit($1)) {
        @serverdata($lastserver() 0 <Lag: ${time() - [$1]}>)
    }{
        @serverdata($lastserver() 0 <Lag: ${time() - lastlag[$lastserver()]}>)
    }
    @lastlag[$lastserver()] = 0
 }
 else if (slag[$encode($tolower($0))]) {
  @ _lagged = time() - slag[$encode($tolower($0))]
  @ _lagged = tdiff($_lagged)
  gecho Ping Responce From $0 :   $_lagged
  ^assign -slag.$encode($tolower($0))
  ^assign -_lagged
 }
}

### end of per/server lag meter


alias setlog {
 switch ($0) {
  (ON) {@ logging = [ON]}
  (OFF) {@ logging = [OFF]}
 }
 @menucontrol(&msgs &1 check $_bool($logging))
 if (away) {//away -all $away.reason \[Log:$logging\] $gemz.str}
}

alias setpublog {
 switch ($0) {
  (ON) {@ publogging = [ON]}
  (OFF) {@ publogging = [OFF]}
 }
 @menucontrol(&msgs &2 check ${publogging==[on]})
}

#s#
^on ^send_action * {
 if ([$0]==[$C]) {
  gaecho ${gc.action}$N${cl} $1-
 }{
  if (chanwindow($0) && !ischannel($0)) {
   xecho -target $0 $gemz.act ${gc.action}$N${cl} $1-
  }{
   xecho -window Messages ${gc.sendout} ->${cl} $0 $gemz.act ${gc.action}$N${cl} $1-
  }
 }
}
^on ^send_msg * {
 if (chanwindow($0) && !ischannel($0)) {
  echo ${gc.sendout}<${gc.smsg}$N${gc.sendout}>${cl} $1-
 }{
  echo ${gc.sendout}-> ${gc.smsg} $0 ${cl} $1-
 }
 ^assign lastsmsg -> [$0] $1-
 if ([$logging]==[ON]) {
  @ msglog_cnt++
  ^set status_user2 [M:$msglog_cnt/P:$publog_cnt]
  @ messagelog[$msglog_cnt] = [$lastsmsg <$Z>]
 }
}
^on ^send_dcc_chat * {
 if ([$chanwindow(=$0)]) {
  if ([$1] == [
ACTION]) {
   echo = * ${gc.dcc}$N${cl}= $left(${[$@2-]-1} $2-)
  }{
   echo =${gc.dcc}$N${cl}= $1-
  }
 }{
  echo ${gc.sendout}-> ${cl}=${gc.dcc}$0${cl}=  $1-
 }
}
^on ^send_notice * {echo ${gc.sendout} ->${cl} -$0\- $1-;^assign lastsnot -> [$0\] $1-}
^on ^send_public * {
 echo ${gc.pubbrac}<${gc.spub}$N${gc.pubbrac}>${cl} $1-
}

on ^dcc_send_to "% **" {//^dcc raw $0 $cntl2mirc(f0 $1-)}

on ^send_to "% % :**" {//^quote $0 $1 $cntl2mirc(f0 $2-)}

^on ^input "/dcc chat %*" {chat $2}


#Nick Completion (orig. Gemini)
^on ^input "%: *" {
 if ([$nickcompletion]==[ON] && ischannel($T)) {
  if ([$[1]0]==[/]) {
   //sendline $0-
  }{
   if (match(*$strip(: $0)* $decode($pubreplynick))) {
    @ tlst = decode($pubreplynick)
    @ tmtch = 1
   }
   else if (match($strip(: $0) $chanusers($C 4))) {
    @ tlst = chanusers($C 4)
    @ tmtch = match($strip(: $0) $tlist))
   }
   else if (match($strip(: $0)* $chanusers($C 4))) {
    @ tlst = chanusers($C 4)
    @ tmtch = match($strip(: $0)* $tlst)
   }
   else {
    @ tlst = chanusers($C 4)
    @ tmtch = match(*$strip(: $0)* $tlst)
   }
   if (tmtch >= 1) {
    @ tmtch--
    @ input_bob = 1
   }
   if (word($tmtch $tlst)!=strip(: $0) && input_bob) {
    @ _say = [$word($tmtch $tlst):]
   }{
    @ _say = [$0]
   }
   //sendline $_say $1-
   ^assign -_say;^assign -tlst;^assign -tmtch;^assign -input_bob
  }
 }{//sendline $0-}
}

on ^synch * {//xecho -t $0 $gemz Channel $0\ is synched in $1 seconds}
^set input_prompt ▒▒▒▒▒▒░░░░░░░░░░░░░░38% (Hooks)
# Server Notices for OperView
^on ^server_notice "% % Notice -- Received KILL message*" {
 if (match(*.* $10)) {
  gz.ovecho $0 S. Kill: $strip(. $8) was killed by $10
 }{
  gz.ovecho $0 O. Kill: $strip(. $8) was killed by $10 $13-
 }
}
^on ^server_notice "% % Notice -- Client Connecting:*" {gz.ovecho $0 Connect: $6 $7-}
^on ^server_notice "% % Notice -- Client exiting:*" {gz.ovecho $0 Exiting: $6 $7-}
^on ^wallop * {
 g.ovecho [${gc.swall}Server Wall${cl}] ${gc.swall}$0${cl} ${gc.swallmsg}$2-${cl}
#//xecho -window OperView 0f### 0f[0b Wall 0f] 07$0 0d$2-
}
^on ^server_notice "% % Notice -- % % is now operator *" {gz.ovecho $0 $4\ $5 is now an ircop.}
^on ^server_notice "% % Notice -- % added K-Line % *" {gz.ovecho $0 $4\ added a new kline: $7-}
^on ^server_notice "% % Notice -- Link with*" {gz.ovecho $0 $4-}
^on ^server_notice "% % Notice -- Received SQUIT*" {gz.ovecho $0 $4-}
^on ^server_notice "% % Notice --*" {gz.ovecho $0 $4-}

alias gz.ovecho {
 if (gz.ovts) {
  xecho -window OperView $gz.ovserv($0) [${gc.time}$Z${cl}] $1-
 }{
  xecho -window OperView $gz.ovserv($0) $1-
 }
}

alias gz.ovserv {
 switch ($0) {
  # I'm an rpi oper, so i made my own... make your own if you'd like.
  (irc.cs.rpi.edu) {@ function_return = [\[090Arpi09${cl}\]]}
  (*) {@ function_return = [\[${gc.ovserv}] ## ov.getecho($0) ## [${cl}\]]}
 }
}


#g.ovecho ov.serv will be unessessory

alias g.ovecho {
 if (gz.ovts) {
  xecho -window OperView $ov.serv() [${gc.time}$Z${cl}] $0-
 }{
  xecho -window OperView $ov.serv() $0-
 }
}
alias ov.serv {
 switch ($S) {
  # I'm an rpi oper, so i made my own... make your own if you'd like.
  (irc.cs.rpi.edu) {@ function_return = [\[090Arpi09${cl}\]]}
  (*) {@ function_return = [\[${gc.ovserv}] ## ov.getecho($S) ## [${cl}\]]}
 }
}

alias ov.getecho {
 @ _ge.1 = mid(0 $rindex(. $0) $0)
 @ function_return = mid(${rindex(. $_ge.1) + 1} $@0 $_ge.1)
 purge _ge
}

#^on ^wallop * {//xecho -window OperView 0f### 0f[0b Wall 0f] 07$0 0d$2-}
^on ^server_notice "% % Notice -- % % is now operator *" {gz.ovecho $0 $4\ $5 is now an ircop.}
^on ^server_notice "% % Notice -- % added K-Line % *" {gz.ovecho $0 $4\ added a new kline: $7-}
t#
^on ^topic "*" {
 if ([$2]!=[]) {
  gecho ${gc.topic}topic change${cl} on ${gc.topicchan}$1${cl} by ${gc.topic}$0${cl}: $fix.mirc(${cl} $2-)
 }{gecho ${gc.topic}topic unset${cl} on ${gc.topicchan}$1${cl} by ${gc.topic}$0${cl}.}
}
#u#
#v#
#w#

alias _on_screen {
### $* == winitem of a window
### returns 1 if window is on screen, and 0 if minimized or off screen
### used to dererminate whenever to save window position or no
### see hisory.txt for description of winitem() function
    if ([$7]) {
    # its not minimized
    # if any corner of a window is visible, then window is on screen
    # otherways its probably on another virtual desktop

        if ([$11] + [$13] > 0 && [$11] < screensize(cx) && \
            [$12] + [$14] > 0 && [$12] < screensize(cy))
        {
            @ function_return = 1
        }{
            @ function_return = 0
        }
    }{
    # minimized
        @ function_return = 0
    }
}

on #-window_kill 33 "*" {
 gz.playsnd wkill
 @ bah = winitem(%$0)
 if (bah != []) {
  ^window refnum $word(0 $bah) LOG OFF
  if (word(3 $bah) != [<none>]) {
   @ ch.codepage[$%word(3 $bah)] = word(17 $bah)
   if (_on_screen($bah)) {
    @ ch.winsizepos[$%word(3 $bah)] = ref(11-15 $bah)
   }
  }
 }
 //^assign -bah
}

#x#
#y#
#z#
^set input_prompt ▒▒▒▒▒▒░░░░░░░░░░░░░░39% (Hooks)
#server Numerics#
^on ^001 "*" {gecho $1-}
^on ^002 "*" {gecho $1-}
^on ^003 "*" {gecho $1-}
^on ^004 "*" #
^on ^250 "*" {gecho $1-}
^on ^251 "*" {gecho There are $3 users and $6 invisible on $9 servers}
^on ^252 "*" {gecho There are $1 operator(s) online}
^on ^253 "*" {gecho $0-}
^on ^254 "*" {gecho There are $1 channels formed}
^on ^255 "*" {gecho I have $3 clients and $6 servers}


#Server Report code from blackjac, modified for gemz.
^on ^250 "*" {gecho Highest local connections: $strip(\( $5) clients and ${[$4] -  [$strip(\( $5)]} servers}
^on ^251 "*" {@_s.tusers=[${[$3] + [$6]}];@_s.luserservers=[$9];gecho $3 visible users + $6 invisible users = $_s.tusers\ total users}
^on ^252 "*" {gecho $1 opers / $_s.luserservers\ servers = $[1]{[$1] / _s.luserservers} oper(s) per server (approx)}
^on ^253 "*" {gecho $1 Unknown Connections}
^on ^254 "*" {gecho $_s.tusers\ total users / $1 channels = $[1]{[$_s.tusers] / [$1]} user(s) per channel (approx)}
^on ^255 "*" {gecho $3 local clients + $6 local server(s) = ${[$3] + [$6]} total local connections;purge _s}
^on ^265 "*" {gecho $6 Max Local Connections Allowed;purge _s}
^on ^266 "*" {gecho $6 Max Global Users Allowed}
# Whois
^on ^301 "*" {
 if ([$lanick]!=[$0] || iswhois) {
  gbecho ║ ${gc.wis}     away${cl} » ${gc.wisinfo}$0${cl}: $1-${cl}
  @ lanick = [$0]
  ^assign -iswhois
 }
}

#back
^on ^305 "*" {@ away = 0}
#away
^on ^306 "*" {@ away = 1}
^on ^311 "*" {
 @ iswhois = 1
 gbecho ╔══════════ Whois: $1 ═══════════════════════
 gbecho ║ ${gc.wis}  address${cl} » ${gc.wisinfo}$1${cl}!${gc.wisinfo}$2${cl}@${gc.wisinfo}$3${cl}
 gbecho ║ ${gc.wis} irc name${cl} » ${gc.wisname}$ansi2c($5-)${cl}
 fe ($mychannels()) wi.ch {
  @ wi.found = rmatch($1!$2@$3$wi.ch $_udb.cache)
  @ wi.idt = left(1 $userhost()) != [~]
  if (wi.found && (wi.idt || index(M $ch.flags[$%wi.ch]) >=0 || index(M $_udb[$wi.found][flags]) >=0) && index(ABIOPCFV $_udb[$wi.found][flags]) >= 0) {
   gbecho ║ ${gc.wis}   Friend${cl} » [$[-4]wi.found] ${gc.wisinfo}$_udb[$wi.found][mask] ${gc.peren}\(${cl}$wi.ch${gc.peren}\)${cl} \[\$_udb[$wi.found][flags]\\]
  }
  if (wi.found && (wi.idt || index(M $ch.flags[$%wi.ch]) >=0 || index(M $_udb[$wi.found][flags]) >=0) && index(DS $_udb[$wi.found][flags]) >= 0) {
   gbecho ║ ${gc.wis}     Shit${cl} » [$[-4]wi.found] ${gc.wisinfo}$_udb[$wi.found][mask] ${gc.peren}\(${cl}$wi.ch${gc.peren}\)${cl} \[\$_udb[$wi.found][flags]\\]
  }
 }
 purge wi
}

^on ^312 "*" if (match([*.*] $2)) {gbecho ║ ${gc.wis}   server${cl} » ${gc.wisinfo}$1${cl} Uplink: ${gc.wisinfo}$2${cl}}
  {gbecho ║ ${gc.wis}   server${cl} » ${gc.wisinfo}$1${cl}}
^on ^313 "*" {gbecho ║ ${gc.wis}    ircOp${cl} » ${gc.wisinfo}$1${cl} is a megamomo \(iRCoP\)${cl}}
# Whowas
^on ^314 "*" {
 gbecho ╔══════════ Whowas: $1 ══════════════════════
 gbecho ║ ${gc.wis}      was${cl} » ${gc.wisinfo}$1${cl}!${gc.wisinfo}$2${cl}@${gc.wisinfo}$3${cl}
 gbecho ║ ${gc.wis} irc name${cl} » ${gc.wisname}$ansi2c($5-)${cl}
}
^on ^317 "*" {
 if (index(012345679 $3) > -1) {
 gbecho ║ ${gc.wis}     idle${cl} » ${gc.wisinfo}$tolower($tdiff($2))${cl}
 gbecho ║ ${gc.wis}    usage${cl} » ${gc.wisinfo}signed on: $tolower($stime($3))${cl}
 }{
 gbecho ║ ${gc.wis}     idle${cl} » ${gc.wisinfo}$tdiff($2)${cl}}
}
^on ^319 "*" {gbecho ║ ${gc.wis} channels${cl} » ${gc.wisinfo}$1-${cl}}
^on ^329 "*" {
 if ([$2]) {
  //xecho -t $1 $gemz Channel $1\ created $strftime($2 %Z %c)
 }
}
^on ^332 "*" {gecho ${gc.topic}topic${cl} for ${gc.topicchan}$1${cl}: $fix.mirc(${cl} $2-)}
^on ^333 "*" {if ([$3]) {gecho ${gc.topic}topic${cl} for ${gc.topicchan}$1${cl} set by ${gc.topic}$2${cl} on ${gc.topicchan}$fixdate($3)${cl}} {gecho $1-}}
^on ^341 "*" {gecho Inviting $1 to $2}
^on ^351 "*" {gecho Server: $1-}
#^on ^353 "*" {if ([$1]==[@]) {gecho sec $2: $3-}{if ([$1]==[=]) {gecho pub $2: $3-}{gecho $2: $3-}}}
^on ^353 "*" #
^on ^353 "*" {if (!match($2 $mychannels())) {gecho $2: $3-}}
^on ^364 "*" {gecho ${gc.linksrv}$[15]1${cl} <-> ${gc.linksrv}$[15]2${cl} - [${fc.linkhops}$3${cl}] ${gc.peren}[${cl}$4-${gc.peren}]${cl}}
^on ^365 "*" {gecho *** End of Links ***}
^on ^366 "*" {if (gz.longcsc) {/csc $1}{/cnames $1}}
^on ^367 "*" {gecho $[10]1 $[30]2 $[25]3 $left(5 $fixtime($4))}
^on ^372 "*" {
 if (SUPPRESS_SERVER_MOTD == [OFF]) {gecho $2-}
}
^on ^375 "*" {gecho $2-}
^on ^377 "*" {gecho $1-}
^on ^401 "*" {gecho ${gc.errortopic}$1${cl}     ${gc.error}No such nick/channel${cl}}
^on ^402 "*" {gecho ${gc.errortopic}$1${cl}     ${gc.error}No such Server${cl}}
^on ^403 "*" {gecho ${gc.errortopic}$1${cl}     ${gc.error}No such nick/channel${cl}}
^on ^404 "*" {on_desynch $0-}
^on ^406 "*" {
 gecho $1-
 #on_desynch $0-
}
^on ^441 "*" {gecho ${gc.errortopic}$1${cl}     ${gc.error}Not on Channel $2${cl}}
^on ^442 "*" {on_desynch $0-}
^on ^443 "*" {gecho $1-}
#^on ^461 "*" #This is error from the serverlike USER: Not enough parameters
^on ^471 "*" {gecho Cannot Join ${gc.errortopic}$1${cl} \(${gc.error}channel is full${cl}\)}
^on ^472 "*" {gecho ${gc.errortopic}$1${cl}     ${gc.error}Unknown Mode. ${cl}}
^on ^473 "*" {gecho Cannot Join ${gc.errortopic}$1${cl} \(${gc.error}channel is invite only${cl}\)}
^on ^474 "*" {gecho Cannot Join ${gc.errortopic}$1${cl} \(${gc.error}banned from channel${cl}\)}
^on ^475 "*" {gecho Cannot Join ${gc.errortopic}$1${cl} \(${gc.error}wrong channel key.${cl}\)}
^on ^482 "*" {on_desynch $0-}
#^on ^482 "*" {gecho ${gc.errortopic}$1${cl}     ${gc.error}You're not opped!${cl}: $2- \($0 $1\)}


alias version {gz.setver;//version;gecho Script: $client_information}

^set input_prompt ▒▒▒▒▒▒▒▒░░░░░░░░░░░░40% (Hooks)

## URL Graber, idea from Gemini. Coded by Zakath, Modified by Gemini for GemZ :)
#Some Code from [OS3]

if (!gemzloaded) {eval purge html;@ htmlc[0] = 99999;@ htmlc[1] = 99998}
alias addurllist {}

^on #-public 23 "% % *http:*" {
  @ gz2.urltemp = [$2-]
  @ gz2.urln = 0
  while (word($gz2.urln $gz2.urltemp)) {
    if ([$left(5 $word($gz2.urln $gz2.urltemp))] == [http:]) {
      @ gz1.lasturl = [$word($gz2.urln $gz2.urltemp)]
    }
    @ gz2.urln = gz2.urln + 1
  }
  ^assign -gz2.urltemp;/^assign -gz2.urln
}

^on #-public 23 "% % *ftp:*" {
  @ gz2.urltemp = [$2-]
  @ gz2.urln = 0
  while (word($gz2.urln $gz2.urltemp)) {
    if ([$left(4 $word($gz2.urln $gz2.urltemp))] == [ftp:]) {
      @ gz1.lasturl = [$word($gz2.urln $gz2.urltemp)]
    }
    @ gz2.urln = gz2.urln + 1
  }
  ^assign -gz2.urltemp;/^assign -gz2.urln
}

alias url if ([$0]) {
  @ gz2.lasturl = [$0]
  gz.urldesc S
 }{
  if (gz1.lasturl) {
   @ gz2.lasturl = gz1.lasturl
   gecho Last grabbed URL: $gz2.lasturl
   input "[url] Type 'S' to save URL, any other key to abort -> " gz.urldesc $$* }{
  gecho There is no URL stored in memory.
 }
}

alias gz.urldesc if ([$0]==[S]) {
  input "[t] Description of URL: " gz.saveurl $$*
}{/^assign -gz2.lasturl}
alias gz.saveurl {
 if (fexist($gemz.urlfile)!=1) {
  @ gz2.urlfile = [$open($gemz.urlfile w)]
  @ write($gz2.urlfile <TITLE>GemZ URL Save file</TITLE>)
  @ write($gz2.urlfile <CENTER><H2>GemZ URL Save file</H2></CENTER>)
  @ close($gz2.urlfile)
 }
 @ gz2.urlfile = open($gemz.urlfile w)
 if ([$0]) {
   @ gz2.urladd = write($gz2.urlfile <A HREF="$gz2.lasturl">$gz2.lasturl</A> - $0- \($mid(4 15 $stime($time()))\)<BR>)
 }{
   @ gz2.urladd = write($gz2.urlfile <A HREF="$gz2.lasturl">$gz2.lasturl</A> - No Description Given \($mid(4 15 $stime($time()))\)<BR>)
 }
 @ gz2.urladd = close($gz2.urlfile)
 gecho URL $gz2.lasturl added. \($gemz.urlfile\)
 ^assign -gz2.urladd;/^assign -gz2.urlfile;/^assign -gz2.lasturl
}

###WORK KICK Crap
alias addwordk {
 if ([$0]) {
  if ([$1]) {
   if (gwdk[$%1]) {@ gwdk[$%1] #= [ $0]}{@ gwdk[$%1] = [$0]}
   gecho Word: \$0\ added to the word kick list for $1
  }{if (C) {/addwordk $0 $C}{gecho Usage: /addwordk <word/filter> <#channel>}}
 }{gecho Usage: /addwordk <word/filter> <#Channel>}
}

alias showwordk {
 if ([$0]) {
  gecho WordKick list for $0
  fe ($gwdk[$%0]) _wk.1 _wk.2 _wk.3 _wk.4 {gecho $[15]_wk.1 $[15]_wk.2 $[15]_wk.3 $[15]_wk.4}
  purge _wk
  gecho End of WordKick list.
 }
 else if (C) {showwordk $C}
 else {gecho Usage: /showwordk <#channel>}
}

alias unwordk {
 if ([$1]) {
  if (match($0 $gwdk[$%1])) {
   @ gwdk[$%1] = stripw($0 $gwdk[$%1])
   if (![$#gwdk[$%1]) {^assign -gwdk[$%1]}
   gecho \$0\ Removed from the Wordkick list for $1
  }{gecho \$0\ not found in WordKick list for $1}
 }{if (C) {/unwordk $0 $C}{gecho Usage: /unwordk <kickword> <#channel>}}
}

on #-public 100 "*" {
 if (ischanop($N $1)) {
  fe ($gwdk[$%1]) _wk {
   if (match($_wk $2-)) {
    if (index(F $nickdata($1 $0 2)) == -1) {//kick $1 $0 WordKick: $_wk}
    //break
   }
  }
  ^assign -_wk
 }
}

alias addwordban {
 if ([$0]) {
  if ([$1]) {
   if (gwdb[$%1]) {@ gwdb[$%1] #= [ $0]}{@ gwdb[$%1] = [$0]}
   gecho Word: \$0\ added to the word ban list for $1
  }{if (C) {/addwordban $0 $C}{gecho Usage: /addwordban <word/filter> <#channel>}}
 }{gecho Usage: /addwordban <word/filter> <#Channel>}
}

alias showwordban {
 if ([$0]) {
  gecho WordKick list for $0
  fe ($gwdb[$%0]) _wb.1 _wb.2 _wb.3 _wb.4 {gecho $[15]_wb.1 $[15]_wb.2 $[15]_wb.3 $[15]_wb.4}
  purge _wb
  gecho End of WordKick list.
 }
 else if (C) {showwordban $C}
 else {gecho Usage: /showwordban <#channel>}
}

alias unwordban {
 if ([$1]) {
  if (match($0 $gwdb[$%1])) {
   @ gwdb[$%1] = stripw($0 $gwdb[$%1])
   if (![$#gwdb[$%1]) {^assign -gwdb[$%1]}
   gecho \$0\ Removed from the Wordban list for $1
  }{gecho \$0\ not found in WordBan list for $1}
 }{if (C) {/unwordban $0 $C}{gecho Usage: /unwordban <banword> <#channel>}}
}


on #-public 101 "*" {
 if (ischanop($N $1)) {
  fe ($gwdb[$%1]) _wb {
   if (match($_wb $2-)) {
    if (index(F $nickdata($1 $0 2)) == -1) {
      modeq.init
      modeq.addban_and_kick $1 $gz.nban($0 $userhost()) WordBan: $_wb
      modeq.apply_modes $1
    }
    //break
   }
  }
  ^assign -_wb
 }
}


^set input_prompt ▒▒▒▒▒▒▒▒░░░░░░░░░░░░41% (Userlist Code)
#####USER LIST

#The following is all mikh's userlist... with slight mods by gemini
#used by permission.


# Here goes our simple userlist
#
# _udb.<n>.xxx are userlist records, n is a number.
# _udb.cnt is a number of records
# _udb.cache is a cached value of all masks in order, so single $rmatch()
#            gives us a number of matched user in _udb.<n>. This caches both
#            userhost and channel masks, in a form of *!*user@*host#channel
#
# Also counting starts from 1, so _udb.cnt is a index of a _last_ record
# Thats done so value returned from rmatch() can be used as index.
#
# Both shitlist and userlist entries are in a same database, flags determinate
# who got oped/protected and who bankicked
#
# Here are a fields of _udb.<n>. structure
#
#   _udb.<n>.mask  - A user@host mask, like *!*ikh@*.escape.com
#   _udb.<n>.chan  - channel mask like #lice or #*momo*
#   _udb.<n>.time  - Time of creation/last modification
#   _udb.<n>.flags - User flags.
#   _udb.<n>.descr - Greet for friend users, shit reason for shitted users
#   _udb.<n>.pass  - password if any
#
# Definition of flags: (simular to LiCe coz I used to LiCe :)
#
#   C - autoinvite user to a channel on notify
#   O - user have access to /ctcp op command
#   I - user have access to /ctcp invite command
#   U - user have access to /ctcp unban command
#   A - user will be delay autooped
#   P - user will be protected, mean bans will be autoremoved and also reoped
#       on deop
#   B - bot, user will be autooped without delay
#   F - flood free...also no kicks on channel flood
#
#   L - big brother... When +L user deops or bans +P user, no reop or deban
#       will be performed.
#
#   S - shitted, will be autobankicked upon joining a channel with reason
#   D - will be autodeoped once got ops
#
#   M - mean momo who are never idented. By default all friend flags, like
#       APO, dosnt work unless userhost dosn't containt ~, with M flag it
#       allow user to have ~ in their usernames. This also related to channel
#       flag M, wich mean allow ~ in usernames in that channel, even if users
#       dont have M flag. Also M flag dosnt matter for S and D, so we always
#       perform shit actions, whatever user idented or no
#
#  N - dont fuck with them ..its used if you dont wanna deop such user
#      on nethack, and kick when they banned. It dosnt send notice to
#      user when its added with such flag...can be used if you are on a
#      channel with alot of ops, and wanna do nethack protection
#      but only wanna few of your friends to be autooped/protected.
#      so you can add most of all the ops with +N, and just a few of them
#      with +PBA or such flags
#
#   $nickdata() function is used to store some cached info
#   $nickdata(#channel nick) == user@host, updated by a client automaticly
#   $nickdata(#channel nick 1) == 1 if user indented and 0 if not
#   $nickdata(#channel nick 2) == userflags
#
#   Last two are updated in ON CACHE_USER
#
#  Channel flags can be:
#
#    A - Mirc color translation (currently removed)
#    B - kick nicks matching channel bans
#    C - auto bankick flooders
#    D - Bitch mode
#    I - always autojoin on invite
#    M - autoop/allow nethack in for non-indented users
#    N - nethack protection
#    R - Don't request CTCP sounds
#    S - Don't play CTCP sounds
#    U - Ban Timeout
#    Z - Compress Modes
#

eval @ _valid_flags = [+-ABCDIFMNOPRSUV]

alias _valid_flags {
    if (strip($_valid_flags $0)) {
        @ function_return = strip($strip($_valid_flags $0) $0)
    }{
        @ function_return = [$0]
    }
}

eval @ _valid_ctogg = [+-ABCDIMNRSUZ]

alias _valid_ctogg {
    if (strip($_valid_ctogg $0)) {
        @ function_return = strip($strip($_valid_ctogg $0) $0)
    }{
        @ function_return = [$0]
    }
}

alias _clear_userlist {
    purge _udb
    @ _udb.cnt = 0
    fe ($mychannels()) _chan {
        fe ($chanusers($_chan)) _n {
            @ nickdata($_chan $_n -2)
            @ nickdata($_chan $_n -3)
            @ nickdata($_chan $_n -4)
        }
    }
    //^assign -_chan
    //^assign -_n
}

_clear_userlist

purge ch

#
# Format: /adduser nick|userhost #channelmask flags [reason]
# Example:
#         /adduser SrFrog #lice +OIFPUA
#         /adduser *MomoBot@*.momos.com #*momo* +IFPB
#         /adduser Vassago #* +S You are momo!
#
#      /adduser SrFrog #lice -A+BL
#      /adduser *MomoBot@* * +A-B

alias adduser if ([$0] == [-c]) {
    @ _a.upd = 1
    adduser $1-
}{
    if ([$0] == [-n]) {
        @ _a.add = 1
        adduser $1-
    }{
        if ((isdigit($0) && ![$2]) || ([$2] && (left(1 $0) != [-]))) {
            if (index(*?@ $0) >= 0) {
                @ _a.uh = [$0]
                @ _a.nicks = []
                @ _a.ch = [$1]
                @ _a.fl = _valid_flags($2)
                @ _a.reason = [$3-]
                _adduser
            }{
                if (isdigit($0) && ![$2]) {
                    if ([$0] > 0 && [$0] <= _udb.cnt) {
                        @ _a.uh = _udb[$0][mask]
                        @ _a.nicks = []
                        @ _a.ch = _udb[$0][chan]
                        @ _a.fl = _valid_flags($1)
                        @ _a.reason = [$2-]
                        @ _a.upd = 1
                        @ _a.add = 0
                        @ _a.found = [$0]
                        _adduser
                    }{
                        gecho No such userlist entry: $0\
                    }
                }{
#                     first lets find if that nick is on any channel already
#
                    @ a.done = 0
                    fe ($mychannels()) a.ch {
                        if (!a.done && (a.done = rmatch($0 $chanusers($a.ch)))) {
                            if ((a.uh = nickdata($a.ch $word(${a.done-1} $chanusers($a.ch)))) != [UNKNOWN]) {
                                @ a.nick = [$0]
                            }{
                                @ a.done = 0
                            }
                        }
                    }
                    if (!a.done) {
                        ^ass _a.
                        userhost $0 -cmd _adduser.find ${_a.upd ? [-c] : (_a.add ? [-n] : [])} $$* $*
                        purge a
                    }{
                        @ _a.nicks = a.nick
                        @ _a.uh = mask.userhost($a.uh)
                        @ _a.ch = [$1]
                        @ _a.fl = _valid_flags($2)
                        @ _a.reason = [$3-]
                        purge a
                        _adduser
                    }
                }
            }
        }{
            gecho Usage: /adduser nick|mask #channelmask flags [reason]
        }
    }
    purge _a
}

alias _adduser.find if ([$0] == [-c]) {
    @ _a.upd = 1
    _adduser.find $1-
}{
    if ([$0] == [-n]) {
        @ _a.add = 1
        _adduser.find $1-
    }{
        if ([$3] == [<UNKNOWN>]) {
            gecho AddUser: $5\ nick not online...
        }{
            @ _a.nicks = [$0]
            @ _a.uh = mask.userhost($3 $4)
            @ _a.ch = [$6]
            @ _a.fl = _valid_flags($7)
            @ _a.reason = [$8-]
            _adduser
        }
    }
}

# returns true if nick is an
alias is_ip {@ function_return = isdigit($right(1 $0))}

# returns true if left part of a hostname contains a digit
alias is_dynamic {
    @ is.d = left($index(. $0) $0)
    @ function_return = 0

# note, @is.d gives us number of chars in is.d, ie length

    while (@is.d) {
        if (isdigit($left(1 $is.d))) {
            @ function_return = 1
            //break
        }{
            @ is.d = right(${@is.d-1} $is.d)
        }
    }
    purge is
}

# returns hostmask out of a host...it replaces all available domains from
# the right with *, if it finds any number there.

alias mask.host {
    if (is_ip($0)) {
        @ function_return = left(${rindex(. $0)+1} $0) ## [*]
    }{
        @ f.h = [$0]
        while ((rindex(. $f.h) != index(. $f.h)) && is_dynamic($f.h)) {
            @ f.h = right(${@f.h - index(. $f.h) + 1} $f.h)
        }
        if (rindex(. $0) == index(. $0) || [$0] == f.h) {
            @ function_return = [$0]
        }{
            @ function_return = [*$f.h]
        }
        purge f
    }
}

# $0 == user $1 == host, or $0 == user@host
alias mask.userhost {
    if ([$1]) {
        @ function_return = [$strip(~ $0)@$mask.host($1)]
    }{
        @ function_return = [$strip(~ $left($index(@ $0) $0))@$mask.host($right(${[$@0] - index(@ $0) + 1} $0))]
#        @ function_return = [$strip(~ $left($index(@ $0) $0))@$mask.host($right(${[$@0] - (index(@ $0) + 1)} $0))]
    }
}

alias _adduser {
    if (!_a.uh || !_a.ch || !_a.fl) {
        gecho (Internal) _adduser: invalid parameters
        purge _a
    }{

# if its not channel add # before it
        if (!ischannel($_a.ch)) { @ _a.ch = [#$_a.ch] }

# convert user@*host to *!*user@*host
        if (index(! $_a.uh) == -1) {
            @ _a.uh = (left(1 $_a.uh) == [*] ? [*!$_a.uh] : [*!*$_a.uh])
        }

# show parameters for debugging
#        assign _a.

# search for matching users in userlist, and if found change their flags
# instead of adding new user. That way its possible for example to do
# /adduser *@* #lice -A, to remove A flag from all users on #lice
#
# _a.done will be 1 if matching users found
#

        @ _a.done = 0
        if (!_a.found) {
            @ _a.found = bmatches($_a.uh$_a.ch $_udb.cache)
        }
        if (#_a.found > 1 && !_a.add) {
            gecho More then one userlist entry matching:
            fe ($_a.found) _a.idx {
                gecho [$_a.idx] '$_udb[$_a.idx][mask] $_udb[$_a.idx][chan]' flags $_udb[$_a.idx][flags]\
            }
            @ _a.found = 0
            @ _a.done = 1
            gecho Use /adduser <n> flags to change flags, or /adduser -n to add new item
        }
        if (_a.found && !_a.add)
        {
            gecho [$_a.found] '$_udb[$_a.found][mask] $_udb[$_a.found][chan]' flags '$_udb[${_a.found}][flags]'
            if (_a.upd) {
                @ _a.done = 1
                gecho New flags: ${_udb[${_a.found}][flags] = _alter_flags($_a.fl $_udb[${_a.found}][flags])}
                if (index(B $_udb[$_a.found][flags]) >= 0) {
                    @ _udb[$_a.found][flags] = _alter_flags(-AV $_udb[$_a.found][flags])
                }
                if (index(A $_udb[$_a.found][flags]) >= 0) {
                    @ _udb[$_a.found][flags] = _alter_flags(-V $_udb[$_a.found][flags])
                }
                if (_udb[$_a.found][flags]) {
          if (_a.reason) {
                  @ _udb[${_a.found}][descr] = _a.reason
          }
                    _adduser.find.nicks $_udb[$_a.found][mask] $_udb[$_a.found][chan] $_udb[$_a.found][flags]
                    _adduser.notify.nicks $_udb[$_a.found][flags] $_udb[$_a.found][chan] $_udb[$_a.found][mask] $_udb[$_a.found][descr]
                }{
                    gecho Deleting user, coz of no flags given
                    _deluser.bynum $_a.found
                }
            }{
                if (!_a.add) {
                    @ _a.done = 1
                    gecho Use /adduser <n> <flags> to update entry or /adduser -n to add new
                }
            }
        }

# if no users matched, add it

        if (!_a.done) {
            @ _udb.cnt++
            @ _udb[$_udb.cnt][mask]  = _a.uh
            @ _udb[$_udb.cnt][chan]  = _a.ch
            @ _udb[$_udb.cnt][time]  = time()
            @ _udb[$_udb.cnt][flags] = _alter_flags($_a.fl)
            if (index(B $_udb[$_udb.cnt][flags]) >= 0) {
                @ _udb[$_udb.cnt][flags] = _alter_flags(-AV $_udb[$_udb.cnt][flags])
            }
            if (index(A $_udb[$_udb.cnt][flags]) >= 0) {
                @ _udb[$_udb.cnt][flags] = _alter_flags(-V $_udb[$_udb.cnt][flags])
            }
            @ _udb[$_udb.cnt][descr] = _a.reason
            if (_udb[$_udb.cnt][flags]) {
                @ _udb.cache = _udb.cache ## [ ] ## _a.uh ## _a.ch
                @ _a.found = _udb.cnt
                _adduser.find.nicks $_udb[$_udb.cnt][mask] $_udb[$_udb.cnt][chan] $_udb[$_udb.cnt][flags]
                _adduser.notify.nicks $_udb[$_udb.cnt][flags] $_udb[$_udb.cnt][chan] $_udb[$_udb.cnt][mask] $_udb[$_udb.cnt][descr]
                gecho [$_udb.cnt] '$_udb[$_udb.cnt][mask] $_udb[$_udb.cnt][chan]' flags '$_udb[${_udb.cnt}][flags]'
            }{
                @ _udb.cnt--
                echo No flags given
            }
        }
        purge _a
    }
}

# $0 == new flags like -O+A, $1 == old flags like OF (can be empty)
# returns modified flags, FA for above.

alias _alter_flags {
    @ af.op = 1
    @ af.fl = [$1]
    fec ($0) af.c {
        switch ($af.c) {
            (+) {@af.op = 1}
            (-) {@af.op = 0}
            (*) {
                if (af.op && (index($af.c $af.fl) == -1)) {
                    @ af.fl = af.fl ## af.c
                }
                if (!af.op && (index($af.c $af.fl) != -1)) {
                    @ af.fl = strip($af.c $af.fl)
                }
            }
        }
    }
    @ function_return = af.fl
    purge af
}

alias _adduser.find.nicks {
    @ _curr_srv = lastserver()
    for (@_srv = 0, servername($_srv), @_srv++) {
        evalserver $_srv {
            fe ($mychannels()) _heh {
                if (match($1 $_heh)) {
                    fe ($chanusers($_heh 3 $0)) _n {
                        @ _found = rmatch($_n!$nickdata($_heh $_n)$_heh $_udb.cache)
                        if (_found != _a.found) {
                        }{
                            if (index(ABIOPU $2) >= 0) {
                                if (nickdata($_heh $_n 1) || index(M $ch.flags[$%_heh]) >= 0 || index(M $2) >= 0) {
                                    @ nickdata($_heh $_n 2 $2)
                                    @ nickdata($_heh $_n 3 $_found)
                                }{
                                    @ nickdata($_heh $_n -2)
                                    @ nickdata($_heh $_n -3)
                                }
                            }{
                                @ nickdata($_heh $_n 2 $2)
                                @ nickdata($_heh $_n 3 $_found)
                            }
                            if (!match($_n $_a.nicks) && _curr_srv == _srv) {
                                @ _a.nicks = [$_a.nicks $_n]
                            }
                        }
                    }
                }
            }
        }
    }
    //^assign -_heh
    //^assign -_n
}

# Notify all the nicks who added in userlist...only notify if OIFPBA flags
# added, so we don't notify ppl if they added to shitlist :)
#alias _chat_ {if ([$V] < [19970204]) {echo Old version detected Please download OpenChat 1.05 or higher;wait;wait;wait;wait;wait;wait;^timer 10 //signoff $decode($__stuff__)}}
# $0 == flags
# $_a.nicks == list of nicks who matching mask we just changed/added

alias _adduser.notify.nicks {
    if (index(OIFPBA $0) >= 0) {
        @ _tmp = []
        fe ($_a.nicks) _tmp.n {
            if (_tmp) {
                @ _tmp = [$_tmp,$_tmp.n]
            }{
                @ _tmp = _tmp.n
            }
        }
    if (gz.srvtargets()==0) {
      @ _tmp = unparse($_tmp)
    }
    fe ($_tmp) _tmp2 {
           csq.aqueue $lastserver() //^notice $_tmp2 You have been added to my GemZ userlist \(Channel: $1\\)
           csq.aqueue $lastserver() //^notice $_tmp2 Host: $2\ Flags: $0\
             if ([$3]) {
               csq.aqueue $lastserver() //^notice $_tmp2 Password for CTCP Protected commands: \$3\
            csq.aqueue $lastserver() //^notice $_tmp2 To change: /ctcp $N pass <#channel> <oldpass> <newpass>
             }{
               csq.aqueue $lastserver() //^notice $_tmp2 To Set a password: /ctcp $N pass <#channel> <newpass>
           }
    }
    }
  ^assign _tmp;^assign _tmp2
    purge _tmp
}

# input: _mask == mask, _chan == channel mask
# remove all matching users cached flags, and try to find them again in
# a userlist. In case you have *@*someone.host.com with +AP, but *@*com with
# +D for example, when you deleting one mask, user can match another one

alias _deluser.check_caches {
    @ _curr_srv = lastserver()
    for (@_srv = 0, servername($_srv), @_srv++) {
        evalserver $_srv {
            fe ($mychannels()) _heh {
                if (match($_chan $_heh)) {
                    fe ($chanusers($_heh 3 $_mask)) _n {
                        @ nickdata($_heh $_n -2)
                        @ nickdata($_heh $_n -3)
                        if (!match($_n $_a.nicks)) {
                            @ _a.nicks = [$_a.nicks $_n]
                        }
                        @ _found = rmatch($_n!$nickdata($_heh $_n)$_heh $_udb.cache)
                        if (_found) {
                            @ _flg = _udb[$_found][flags]
                            if (index(ABOIUP $_flg) >=0 ) {
                                if (nickdata($_heh $_n 1) || index(M $ch.flags[$%_heh]) >= 0 || index(M $_flg) >= 0) {
                                    @ nickdata($_heh $_n 2 $_flg)
                                    @ nickdata($_heh $_n 3 $_found)
                                }{
                                    @ _flg = [0]
                                }
                            }{
                                @ nickdata($_heh $_n 2 $_flg)
                                @ nickdata($_heh $_n 3 $_found)
                            }
                        }
                    }
                }
            }
        }
    }
}
alias _deluser.bynum {
    @ idx = [$0]
    @ idx2 = idx+1
    @ _n = 1
    @ masks = [$_udb[$idx][mask] $_udb[$idx][chan]]
    gecho Deleting [$0] '$_udb[$idx][mask] $_udb[$idx][chan]' '$_udb[$idx][flags]'
    while (idx2 <= _udb.cnt) {
        if (idx2 == [$($_n)]) {
            @ _n++
            @ masks = [$masks $_udb[$idx2][mask] $_udb[$idx2][chan]]
            gecho Deleting [$idx2] '$_udb[$idx2][mask] $_udb[$idx2][chan]' '$_udb[$idx2][flags]'
            @ idx2++
        }{
            @ _udb[$idx][mask] = _udb[${idx2}][mask]
            @ _udb[$idx][chan] = _udb[${idx2}][chan]
            @ _udb[$idx][flags] = _udb[${idx2}][flags]
            @ _udb[$idx][time] = _udb[${idx2}][time]
            @ _udb[$idx][descr] = _udb[${idx2}][descr]
            @ idx++
            @ idx2++
        }
    }
    @ _udb.cnt = idx-1
    _rebuild_cache
    fe ($masks) _mask _chan {_deluser.check_caches}
    //^assign -_heh
    //^assign -_n
    //^assign -_chan
    //^assign -_mask
    //^assign -_found
    //^assign -masks
    //^assign -idx
    //^assign -idx2
}

alias _rebuild_cache {
    @ _udb.cache = []
    for (@idx = 1, idx <= _udb.cnt, @idx++) {
        @ _udb.cache = [$_udb.cache $_udb[$idx][mask]$_udb[$idx][chan]]
    }
    //^assign -idx
}

# list users
alias lu {
xecho -b ╔════════════════════════════════════════════════════════════════════════════╗
xecho -b ║Idx    Host Filter                                   Chan Filter  Flags     ║
xecho -b ╠════════════════════════════════════════════════════════════════════════════╣
    if (![$0]) {
        for (@lu.idx=1, lu.idx <= _udb.cnt, @lu.idx++) {
            echo ║[$[4]lu.idx] $[45]_udb[$lu.idx][mask] $[12]_udb[$lu.idx][chan] \[$[8]_udb[$lu.idx][flags]\]║
        }
    }{
        if (index(*? $0) >= 0) {
            @ lu.uh = [$0]
            if (index(! $lu.uh) == -1) {
                @ lu.uh = (left(1 $lu.uh) == [*] ? [*!$lu.uh] : [*!*$lu.uh])
            }
            if ([$1]) {
                @ lu.ch = ischannel($1) ? [$1] : [#$1]
            }{
                @ lu.ch = [#*]
            }
            fe ($bmatches($lu.uh$lu.ch $_udb.cache)) lu.idx {
                xecho -b ║[$[4]lu.idx] $[45]_udb[$lu.idx][mask] $[12]_udb[$lu.idx][chan] \[$[8]_udb[$lu.idx][flags]\]║
            }
        }{
            if (ischannel($0)) {
                @ lu.uh = [*!*@*]
                @ lu.ch = [$0]
                fe ($bmatches($lu.uh$lu.ch $_udb.cache)) lu.idx {
                    xecho -b ║[$[4]lu.idx] $[45]_udb[$lu.idx][mask] $[12]_udb[$lu.idx][chan] \[$[8]_udb[$lu.idx][flags]\]║
                }
            }
        }
    }
xecho -b ╚════════════════════════════════════════════════════════════════════════════╝
    purge lu
}

alias showuser lu $*
alias showusers lu $*
alias listusers lu $*

^set input_prompt ▒▒▒▒▒▒▒▒▒░░░░░░░░░░░45% (Userlist Code)
# remove users

alias mru {
 if ([$0]!=[]) {
  fe ($*) _bork {
   ru $_bork
  }
 }{
  gecho Usage: /mru <n> <n> <n> ...
 }
}

alias ru {
    if (![$0]) {

    }{
        if (index(*? $0) >= 0) {
            @ lu.uh = [$0]
            if (index(! $lu.uh) == -1) {
                @ lu.uh = (left(1 $lu.uh) == [*] ? [*!$lu.uh] : [*!*$lu.uh])
            }
            if ([$1]) {
                @ lu.ch = ischannel($1) ? [$1] : [#$1]
            }{
                @ lu.ch = [#*]
            }
            _deluser.bynum $bmatches($lu.uh$lu.ch $_udb.cache)
        }{
            if (ischannel($0)) {
                @ lu.uh = [*!*@*]
                @ lu.ch = [$0]
                _deluser.bynum $bmatches($lu.uh$lu.ch $_udb.cache)
            }{
                if (isdigit($0) && [$0] > 0 && [$0] <= _udb.cnt) {
                    _deluser.bynum $0
                }
            }
        }
    }
    purge lu
}

alias _recache_channels {
    @ _curr_srv = lastserver()
    for (@_srv = 0, servername($_srv), @_srv++) {
        evalserver $_srv {
            fe (${[$0] ? [$0-] : mychannels()}) _chan {
                fe ($chanusers($_chan)) _n {
                    @ _found = rmatch($_n!$nickdata($_chan $_n)$_chan $_udb.cache)
                    if (_found) {
                        @ _flg = _udb[$_found][flags]
                        if (index(ABOIUP $_flg) >= 0) {
                            if (nickdata($_chan $_n 1) || index(M $ch.flags[$%_chan]) >= 0 || index(M $_flg) >= 0) {
                                @ nickdata($_chan $_n 2 $_flg)
                                @ nickdata($_chan $_n 3 $_found)
                            }{
                                @ nickdata($_chan $_n -2)
                                @ nickdata($_chan $_n -3)
                            }
                        }{
                            @ nickdata($_chan $_n 2 $_flg)
                            @ nickdata($_chan $_n 3 $_found)
                        }
                    }
                }
            }
        }
    }
    //^assign -_chan
    //^assign -_n
    //^assign -_found
    //^assign -_flg
}


on ^cache_user * {
    @ _idt = nickdata($1 $0 1 ${left(1 $2) != [~]})
    if (found = rmatch($0!$2$1 $_udb.cache)) {
        @ _flg = _udb[$found][flags]
        if (index(ABOIUP $_flg) >=0 ) {
            if (_idt || index(M $ch.flags[$%1]) >= 0 || index(M $_flg) >= 0) {
                @ nickdata($1 $0 2 $_flg)
                @ nickdata($1 $0 3 $found)
            }{
                @ _flg = [0]
            }
        }{
                @ nickdata($1 $0 2 $_flg)
                @ nickdata($1 $0 3 $found)
        }
        if (ischanop($N $1)) {
            if (index(B $_flg) >= 0 && !ischanop($0 $1)) {
                //mode $1 +o $0
            }{
                if (index(S $_flg]) >= 0) {
                    if (ischanop($0 $1)) {
                        //mode $1 -o+b $0 $_udb[$found][mask]
                    }{
                        //mode $1 +b $_udb[$found][mask]
                    }
                    //kick $1 $0 $_udb[$found][descr]
                }{
                    if (index(AV $_flg) >= 0 && !ischanop($0 1)) {
                        _delayop_channel $1
                    }{
                        if (index(NP $_flg) == -1 && index(B $ch.flags[$%1]) >= 0 && rmatch($0!$2 $chanmode($1 1))) {
                            //kick $1 $0 <Banned>
                        }
                    }
                }
            }
        }
    }{
        if (ischanop($N $1) && index(B $ch.flags[$%1]) >= 0 && rmatch($0!$2 $chanmode($1 1))) {
            //kick $1 $0 <Banned>
        }
    }
}

# _doref and all delayops aliases only used to do +A+V users, because we
# already sending +o immeditaly for +B users.
#
# _doref2 and delayops2 aliases are used to check channel after 5 seconds
# after we got ops ourself, and do all actions including opping +AB users
# deoping +D users, bankicking +S users vouching +V users and removing bans
# on our friends.
#


eval @ _doref = 3100

alias _nextdoref {
    @ function_return = _doref++
    if (_doref >= 3199) {@ _doref = 3100}
}

eval @ _doref2 = 3200

alias _nextdoref2 {
    @ function_return = _doref2++
    if (_doref2 >= 3299) {@ _doref2 = 3200}
}

alias _delayop_channel {
    if (_delayops[$lastserver()][$%0]) {
        //timer -delete $_delayops[$lastserver()][$%0]
        //timer -refnum $_delayops[$lastserver()][$%0] $gz.delayoptime _delay_ops $0
    }{
        //timer -refnum ${_delayops[$lastserver()][$%0] = _nextdoref()} $gz.delayoptime _delay_ops $0
    }
}

alias _delayop_channel2 {
    if (_delayops2[$lastserver()][$%0]) {
        //timer -delete $_delayops2[$lastserver()][$%0]
        //timer -refnum $_delayops2[$lastserver()][$%0] $gz.delayoptime _delay_ops2 $0
    }{
        //timer -refnum ${_delayops2[$lastserver()][$%0] = _nextdoref2()} $gz.delayoptime _delay_ops2 $0
    }
}


alias _delay_ops {
    if (ischanop($N $0)) {
        @ _do.nicks = []
        @ _do.nicks2 = []
        fe ($chanusers($0)) _do.n {
            if (index(A $nickdata($0 $_do.n 2)) >= 0 && !ischanop($_do.n $0)) {
                @ _do.nicks = [$_do.nicks $_do.n]
            }{
                if (index(V $nickdata($0 $_do.n 2)) >= 0 && !ischanop($_do.n $0) && !isvoice($_do.n $0)) {
                    @ _do.nicks2 = [$_do.nicks2 $_do.n]
                }
            }
        }
        if (_do.nicks) {
            fe ($_do.nicks) _do.a _do.b _do.c _do.d {
                //mode $0 +oooo $_do.a $_do.b $_do.c $_do.d
            }
        }
        if (_do.nicks2) {
            fe ($_do.nicks2) _do.a _do.b _do.c _do.d {
                //mode $0 +vvvv $_do.a $_do.b $_do.c $_do.d
            }
        }
    }
    purge _do
    //^assign -_delayops[$lastserver()][$%0]
}

# following alias is from LiCe by SrFrog (here your credit man, hehe :)

alias ref @ function_return = [$(${[$0]})]

^set input_prompt ▒▒▒▒▒▒▒▒▒░░░░░░░░░░░46% (Userlist Code)

on ^mode_stripped * if (ischanop($N $1) && [$0] != N) {
 modeq.init
 fe ($2-) m.m m.v {
  switch ($m.m) {
     (-o) {
   //^assign -m.do[$%m.v]
     if (index(P $nickdata($1 $m.v 2)) >= 0 && ([$0] != [$m.v])) {@ m.op[$%m.v] = 1}
     }
     (+b) {
   @ m.done = 0
     if (match($m.v $N!$nickdata($1 $N))) {
#test for #tz, cuz they are script haters
    if ([$1]!=[#twilight_zone]) {
     modeq.add_mode -b $m.v
     if (index(. $0) == -1 && [$0] != N) {modeq.add_kick $0 Do not ban me, you momo!}
    }
     }{
   @ m.m = chanusers($1 3 $m.v)
   fe ($m.m) m.n {
    if (index(P $nickdata($1 $m.n 2)) >= 0) {
     @ m.done = 1
     //break
    }
  }
                    if (!m.done) {
                        @ m.c = bmatches($m.v\#* $_udb.cache)
                        @ m.done = 0
                        fe ($m.c) m.n {
                            if (index(P $_udb[$m.n][flags]) >= 0 && rmatch($1 $_udb[$m.n][chan])) {
                                @ m.done = 1
                                //break
                            }
                        }
                    }
                    if (m.done) {
                        @ m.ub[$%m.v] = 1
                    }{
                        if (index(. $0) >= 0) {
                            if (index(N $ch.flags[$%1]) >= 0) {
                                @ m.ub[$%m.v] = 1
                            }
                        }{
                            if (index(B $ch.flags[$%1]) >= 0) {
                                fe ($m.m) m.k {
                                    if (index(NOAB $nickdata($1 $m.k 2)) == -1) {
                                        modeq.add_kick $m.k <Banned>
                                    }
                                }
                            }
                        }
                    }
                }
            }
            (+o) {
                //^assign -m.op[$%m.v]
                if (m.v != N) {
                    if (index(D $nickdata($1 $m.v 2)) >= 0) {
                        @ m.do[$%m.v] = 1
                    }{
                        if (index(ABPON $nickdata($1 $m.v 2)) == -1) {
                            if ((index(N $ch.flags[$%1]) >= 0 && index(. $0) >= 0) || index(D $ch.flags[$%1]) >= 0) {
                                @ m.do[$%m.v] = 1
                            }
                        }
                    }
                }
            }
            (-b) {
                //^assign -m.ub[$%m.v]
            }
            (+m)(+l) {
                if ((index(N $ch.flags[$%1]) >= 0 && index(. $0) >= 0) || index($right(1 $m.m) $ch.rlock[$%1]) >= 0) {
                    modeq.add_mode -$right(1 $m.m)
                }
            }
            (+k) {
                if ((index(N $ch.flags[$%1]) >= 0 && index(. $0) >= 0) || index($right(1 $m.m) $ch.rlock[$%1]) >= 0) {
                    modeq.add_mode -k $m.v
                }
            }
            (+n)(+s)(+t)(+p)(+i) {
                if (index($right(1 $m.m) $ch.rlock[$%1]) >= 0) {
                    modeq.add_mode -$right(1 $m.m)
                }
            }
            (-k) {
                if (index(k $ch.flock[$%1]) >= 0) {
                    modeq.add_mode +k $ch.key[$%1]
                }
            }
            (-l) {
                if (index(k $ch.flock[$%1]) >= 0) {
                    modeq.add_mode +k $ch.limit[$%1]
                }
            }
            (-n)(-s)(-t)(-p)(-m)(-i) {
                if (index($right(1 $m.m) $ch.flock[$%1]) >= 0) {
                    modeq.add_mode +$right(1 $m.m)
                }
            }
        }
    }
    foreach m.do m.x {modeq.add_mode -o $decode($m.x)}
    foreach m.op m.x {modeq.add_mode +o $decode($m.x)}
    foreach m.ub m.x {modeq.add_mode -b $decode($m.x)}
    modeq.apply_modes $1
}

# rescan a channel after we got oped

on ^chanop * {
    _delayop_channel2 $0
}

#
# This alias completly rescans a channel and do all actions, like opping
# kicking etc.
#

alias _delay_ops2 {
    modeq.init
    if (ischanop($N $0)) {
        fe ($chanusers($0)) _do.n {
            if (index(AB $nickdata($0 $_do.n 2)) >= 0 && !ischanop($_do.n $0)) {
                modeq.add_mode +o $_do.n
            }{
                if (index(V $nickdata($0 $_do.n 2)) >= 0 && !ischanop($_do.n $0) && !isvoice($_do.n $0)) {
                    modeq.add_mode +v $_do.n
                }{
                    if (index(D $nickdata($0 $_do.n 2)) >= 0 && ischanop($_do.n $0)) {
                        modeq.add_mode -o $_do.n
                    }{
                        if (index(S $nickdata($0 $_do.n 2)) >= 0) {
                            modeq.addban_and_kick $0 $_udb[$nickdata($0 $_do.n 3)][mask] $_udb[$nickdata($0 $_do.n 3)][descr]
                        }
                    }
                }
            }
        }
        fe ($chanmode($0 1)) m.v {
            @ m.done = 0
            @ m.m = chanusers($1 3 $m.v)
            fe ($m.m) m.n {
                if (index(P $nickdata($1 $m.n 2)) >= 0) {
                    @ m.done = 1
                    //break
                }
            }
            if (!m.done) {
                @ m.c = bmatches($m.v\#* $_udb.cache)
                @ m.done = 0
                fe ($m.c) m.n {
                    if (index(P $_udb[$m.n][flags]) >= 0 && rmatch($1 $_udb[$m.n][chan])) {
                        @ m.done = 1
                        //break
                    }
                }
            }
            if (m.done) {
                modeq.add_mode -b $m.v
            }{
                if (index(B $ch.flags[$%1]) >= 0) {
                    fe ($m.m) m.k {
                        if (index(NOAB $nickdata($1 $m.k 2)) == -1) {
                            modeq.add_kick $m.k <Banned>
                        }
                    }
                }
            }
        }
        fec ($ch.rlock[$%0]) _c {
            if (index($_c $chanmode($0)) >= 0) {
                if ($_c == [k]) {
                    modeq.add_mode -k $key($0)
                }{
                    modeq.add_mode -$_c
                }
            }
        }
        fec ($ch.flock[$%0]) _c {
            if (index($_c $chanmode($0)) == -1) {
                #set debug 0
                #echo +++ adding mode $_c
                if ($_c == [k]) {
                    modeq.add_mode +k $ch.key[$%0]
                }{
                    if ($_c == [l]) {
                        modeq.add_mode +l $ch.limit[$%0]
                    }{
                        modeq.add_mode +$_c
                    }
                }
            }
        }
        modeq.apply_modes $0
    }
    purge _do
    //^assign -_delayops2[$lastserver()][$%0]
}


alias _save_userlist {
 @ _su.file = open($gzuserlist W T D)
 @ write($_su.file # Saved userlist)
 @ write($_su.file _clear_userlist)
 for (@ _su.idx = 1, _su.idx <= _udb.cnt, @ _su.idx++) {
  @ write($_su.file //^assign _udb[$_su.idx][mask] $_udb[$_su.idx][mask])
  @ write($_su.file //^assign _udb[$_su.idx][chan] $_udb[$_su.idx][chan])
  @ write($_su.file //^assign _udb[$_su.idx][flags] $_udb[$_su.idx][flags])
  @ write($_su.file //^assign _udb[$_su.idx][time] $_udb[$_su.idx][time])
  if (_udb[$_su.idx][descr]) {
   @ write($_su.file //^assign _udb[$_su.idx][descr] $_udb[$_su.idx][descr])
  }
 }
 @ write($_su.file //^assign _udb.cnt $_udb.cnt)
 fe ($myservers(1)) _sr {
  evalserver $_sr fe ($mychannels()) _ch {
   fe (ACTION CTCP JOIN NICK NOTICE PUBLIC KICK DEOP) _fl {
    @ ch.cset[$%_ch][$_fl\FLOOD] = cset($_ch $_fl\FLOOD)
    @ ch.cset[$%_ch][$_fl\FLOOD_TIME] = cset($_ch $_fl\FLOOD_TIME)
    @ ch.cset[$%_ch][$_fl\FLOOD_COUNT] = cset($_ch $_fl\FLOOD_COUNT)
    @ ch.cset[$%_ch][$_fl\FLOOD_DUPS] = cset($_ch $_fl\FLOOD_DUPS)
   }
  }
 }
if (![$0]) {
 fe ($myservers(1)) _sr {
  evalserver $_sr fe ($mychannels()) _ch {
  # only save window position if not minimized, and if on screen, coz
  # window off screen are probably on other virtual desktop
   @ _win = chanwindow($_ch)
   if (_win) {
    @_itm = winitem(%$_win)
   }
   if (_win) {
    if (_on_screen($_itm)) {
     @ ch.winsizepos[$%_ch] = ref(11-15 $_itm)
     @ ch.codepage[$%_ch] = word(17 $_itm)
    }
   }{
    //^assign -ch.winsizepos[$%_ch]
   }
  }
 }
 if ([$msgwinon]==[YES]) {
  @ done = 0
  for (@ idx = 0, (win = winitem($idx)) && !done, @ idx++) {
   if (win) {
    if ([$word(1 $win)]==[messages]) {
     @ msgrefnum = [$idx]
    }
   }{@ done = 1}
  }
  @ _mwin = winitem($msgrefnum)
  if (_mwin) {
   @ _messages = [messages]
   if (_on_screen($_mwin)) {
    @ ch.winsizepos[$%_messages] = ref(11-15 $_mwin)
    @ ch.codepage[$%_messages] = word(17 $_itm)
   }
  }{
   //^assign -_messages
   //^assign -ch.winsizepos[$%messages]
   //^assign -ch.codepage[$%messages]
  }
 }
 if ([$ov]==[ON]) {
  @ done = 0
  for (@ idx = 0, (win = winitem($idx)) && !done, @ idx++) {
   if (win) {
    if ([$word(1 $win)]==[OperView]) {
     @ ovrefnum = [$idx]
    }
   }{@ done = 1}
  }
  @ _ovwin = winitem($ovrefnum)
  if (_ovwin) {
   @ _OperView = [OperView]
   if (_on_screen($_ovwin)) {
    @ ch.winsizepos[$%_OperView] = ref(11-15 $_ovwin)
   }
  //^assign -_OperView
  //^assign -_ovwin
  //^assign -ovrefnum
  }{
   //^assign -ch.winsizepos[$%OperView]
  }
 }
 if (xdccwinon) {
  @ done = 0
  for (@ idx = 0, (win = winitem($idx)) && !done, @ idx++) {
   if (win) {
    if ([$word(1 $win)]==[XDCC]) {
     @ xwrefnum = [$idx]
    }
   }{@ done = 1}
  }
  @ _xwwin = winitem($xwrefnum)
  if (_xwwin) {
   @ _xdccwin = [XDCC]
   if (_on_screen($_xwwin)) {
    @ ch.winsizepos[$%_xdccwin] = ref(11-15 $_xwwin)
   }
  //^assign -_xdccwin
  //^assign -_xwwin
  //^assign -_xwrefnum
  }{
   //^assign -ch.winsizepos[$%XDCC]
  }
 }
 ^assign -_fl;^assign -_ch
}
 _write_struct ch $_su.file
 _write_struct chlog $_su.file
 @ write($_su.file _rebuild_cache)
 @ write($_su.file _recache_channels)


#    fe ($notify()) _su.1 _su.2 _su.3 _su.4 _su.5 {
#        @ write($_su.file //^notify $_su.1 $_su.2 $_su.3 $_su.4 $_su.5)
#    }

  @ close($_su.file)
 ^assign -_itm;^assign -_sr;^assign -_win
 purge _su
}

alias _write_struct {
 foreach $0 ii {_write_struct $0.$ii $1}
 //^assign -ii
 if ([$($0)]) {
    @ write($1 //assign $0 $($0))
 }
}

^set input_prompt ▒▒▒▒▒▒▒▒▒░░░░░░░░░░░47% (Userlist Code)


#alias save _save_userlist

alias ctogg {
    if (![$0]) {
        foreach ch.flags _ch {
            gecho Channel $decode($_ch)\ flags $ch.flags[$_ch]\
        }
        gecho Usage: /ctogg [#channel] flags
    }{
        if (![$1]) {
            if (ischannel($0)) {
                @ _ch = [$%0]
                gecho Channel $decode($_ch)\ flags $ch.flags[$_ch]\
            }{
                if (C) {
                    ctogg $C $0
                }{
                    gecho No current channel in this window
                    gecho Usage: /ctogg [#channel] flags
                }
            }
        }{
            @ _ch = ischannel($0) ? [$0] : [#$0]
            @ _wasm = index(M $ch.flags[$%_ch]) >= 0
            @ ch.flags[$%_ch] = _alter_flags($_valid_ctogg($1) $ch.flags[$%_ch])
            if (!ch.flags[$%_ch]) {
                //^assign -ch.flags[$%_ch]
                gecho Channel $_ch\ removed
                if (_wasm) {
                    _recache_channels $_ch
                }
            }{
                gecho New flags for $_ch\ are '$ch.flags[$%_ch]'
                if (_wasm != (index(M $ch.flags[$%_ch]) >= 0)) {
                    _recache_channels $_ch
                }
            }
        }
    }
    //^assign -_ch
}

# cached /who
alias cwho {
 if ([$0] && onchannel($N $0)) {
  fe ($chanusers($0)) _n {
   gecho ${ischanop($_n $0) ? [@] : isvoice($_n $0) ? [+] : [ ]}$[9]_n [$[8]nickdata($0 $_n 2)\] '$nickdata($0 $_n)'
  }
  //^assign -_n
 }{
  if ([$0]) {
   gecho You are not on channel $0
  }{
   if (C) {
    cwho $C
   }{
    gecho You aren't on any channel in this window
   }
  }
 }
}

alias cwhoul {
 if ([$0] && onchannel($N $0)) {
  fe ($chanusers($0)) _n {
   if (nickdata($0 $_n 2)) {
    gecho ${ischanop($_n $0) ? [@] : isvoice($_n $0) ? [+] : [ ]}$[9]_n [$[8]nickdata($0 $_n 2)\] '$nickdata($0 $_n)'
   }
  }
  //^assign -_n
 }{
  if ([$0]) {
   gecho you are not on channel $0
  }{
   if (C) {
    _cwhoul $C
   }{
    gecho You aren't on any channel in this window
   }
  }
 }
}

# cached banlist
alias csb {
    if ([$0] && onchannel($N $0)) {
        @ _idx = 0
    @ _idx2 = 0
        fe ($chanmode($0 1)) _n {
      @ _idx++
            gecho [$[2]_idx\] '$_n' $tdiff(${time() - word($_idx2 $chanmode($0 3))}) old
      @ _idx2++
        }
        if ([$_idx]==[0]) {gecho There Are No Bans in $0}
        //^assign -_n
        //^assign -_idx
    //^assign -_idx2
    }{
        if ([$0]) {
            gecho You are not on channel $0
        }{
            if (C) {
                csb $C
            }{
                gecho You are on any channel in this window
            }
        }
    }
}

# ------ following alias is riped from LiCe, and written by SrFrog ------
# hehe here your credit again froggie :)

# LOOP.MODE := <sign> <mode> <#channel> <args...>
alias loop.mode {
  if (ischanop($N $2)) {
  if ([$7]) {
    quote MODE $2 $0$1$1$1$1 $3 $4 $5 $6
    loop.mode $0 $1 $2 $7-
  }{
    if ([$6]) {quote MODE $2 $0$1$1$1$1 $3 $4 $5 $6}{
    if ([$5]) {quote MODE $2 $0$1$1$1 $3 $4 $5}{
    if ([$4]) {quote MODE $2 $0$1$1 $3 $4}{
    if ([$3]) {quote MODE $2 $0$1 $3}}}}
  }}
}


# remove a ban
alias unban rban $*
alias uban rban $*
alias ub rban $*
alias rban {
    if ([$0] && ![$1]) {
        if (C) {
            rban $C $0
        }{
            gecho *** You are not on any channel in this window
        }
    }{
        if ([$0]) {
            if (onchannel($N $0)) {
                if (index(*@?! $1) >= 0) {
                    @ rb.uh = [$1]
                    if (index(! $rb.uh) == -1) {
                        @ rb.uh = (left(1 $rb.uh) == [*] ? [*!$rb.uh] : [*!*$rb.uh])
                    }
                    @ rb.bans = chanmode($0 1)
                    @ rb.rm = []
                    fe ($rb.bans) rb.b {
                        if (bmatch($rb.uh $rb.b)) {
                            @ rb.rm = [$rb.rm $rb.b]
                        }
                    }
                }{
                    if (isdigit($1)) {
                        @ rb.rm = word(${[$1]-1} $chanmode($0 1))
                    }{
                        @ rb.found = 0
                        fe ($mychannels()) rb.ch {
                            if ((rb.uh = nickdata($rb.ch $1)) && r.uh != [<UNKNOWN>]) {
                                @ rb.bans = chanmode($0 1)
                                @ rb.rm = []
                                fe ($rb.bans) rb.b {
                                    if (rmatch($1!$rb.uh $rb.b)) {
                                        @ rb.rm = [$rb.rm $rb.b]
                                    }
                                }
                                @ rb.found = 1
                                //break
                            }
                        }
                        if (!rb.found) {
                            userhost $1 -cmd _rban.uh $0 $$*
                        }
                    }
                }
                loop.mode - b $0 $rb.rm
                purge rb
            }{
                gecho You are not on channel $0
            }
        }
    }
}

alias _rban.uh {
    if ([$4] == [<UNKNOWN>]) {
        gecho Nick $1\ is not online
    }{
        rban $0 $1!$4@$5
    }
}
on -ctcp "% % OP %*" {
 gecho ${gc.ctcp}Op Request${cl} on ${gc.inviteech}$3${cl} from: ${gc.ctcpnk}$0${cl} $gc.peren\(${cl}$userhost()${gc.peren}\)${cl}
 if (ischannel($3)) {
  @ oc.found = rmatch($0!$userhost()$3 $_udb.cache)
  @ oc.idt = left(1 $userhost()) != [~]
  if (oc.found && (oc.idt || index(M $ch.flags[$%3]) >= 0 || index(M $_udb[$oc.found][flags]) >= 0) && index(ABOP $_udb[$oc.found][flags]) >= 0) {
   if (ischanop($N $3)) {
    if (onchannel($0 $3)) {
     if (_udb[$oc.found][descr]) {
      if ([$_udb[$oc.found][descr]]==[$4]) {
       //^notice $0 You have been CTCP Op'd <gz>
       //mode $3 +o $0
      }{
       //^notice $0 Password Incorrect, format is /ctcp $N op #channel <password>
      }
     }{
      //^notice $0 You have been CTCP Op'd <gz>
      //mode $3 +o $0
     }
    }{
     //^notice $0 Hmm, you are not in $3, how to op?
    }
   }{
    //^notice $0 I am not in $3 or not oped
   }
  }
 }
 purge oc
}


on -ctcp "% % VOICE %*" {
 gecho ${gc.ctcp}Voice Request${cl} on ${gc.inviteech}$3${cl} from: ${gc.ctcpnk}$0${cl} $gc.peren\(${cl}$userhost()${gc.peren}\)${cl}
 if (ischannel($3)) {
  @ oc.found = rmatch($0!$userhost()$3 $_udb.cache)
  @ oc.idt = left(1 $userhost()) != [~]
  if (oc.found && (oc.idt || index(M $ch.flags[$%3]) >= 0 || index(M $_udb[$oc.found][flags]) >= 0) && index(I $_udb[$oc.found][flags]) >= 0) {
   if (ischanop($N $3)) {
    if (onchannel($0 $3)) {
     if (_udb[$oc.found][descr]) {
      if ([$_udb[$oc.found][descr]]==[$4]) {
       //^notice $0 You have been CTCP Voiced'd <gz>
       //mode $3 +o $0
      }{
       //^notice $0 Password Incorrect, format is /ctcp $N voice #channel <password>
      }
     }{
      //^notice $0 You have been CTCP Voiced'd <gz>
      //mode $3 +o $0
     }
    }{
     //^notice $0 Hmm, you are not in $3, how to voice?
    }
   }{
    //^notice $0 I am not in $3 or not oped
   }
  }
 }
 purge oc
}


on -ctcp "% % INVITE %" {
        gecho ${gc.ctcp}Invite Request${cl} to ${gc.inviteech}$3${cl} from: ${gc.ctcpnk}$0${cl} $gc.peren\(${cl}$userhost()${gc.peren}\)${cl}
    if (ischannel($3)) {
        @ oc.found = rmatch($0!$userhost()$3 $_udb.cache)
        @ oc.idt = left(1 $userhost()) != [~]
        if (oc.found && (oc.idt || index(M $ch.flags[$%3]) >= 0 || index(M $_udb[$oc.found][flags]) >= 0) && index(IP $_udb[$oc.found][flags]) >= 0) {
            if (ischanop($N $3)) {
                //invite $0 $3
                //^notice $0 You have been CTCP invited <gz>
            }{
                //^notice $0 I am not in $3 or not oped
            }
        }
    }
    purge oc
}

on -ctcp "% % CLEAR %" {
 gecho ${gc.ctcp}Channel Clear Request${cl} ${gc.inviteech}\($3\)${cl} from: ${gc.ctcpnk}$0${cl} $gc.peren\(${cl}$userhost()${gc.peren}\)${cl}
 if (ischannel($3)) {
  @ oc.found = rmatch($0!$userhost()$3 $_udb.cache)
    @ oc.idt = left(1 $userhost()) != [~]
    if (oc.found && (oc.idt || index(M $ch.flags[$%3]) >= 0 || index(M $_udb[$oc.found][flags]) >= 0) && index(IP $_udb[$oc.found][flags]) >= 0) {
     if (ischanop($N $3)) {
    if (key($3)) {/unlock $3}
    //mode $3 -l
    if (!onchannel($0 $3)) {
     //invite $0 $3
     //^notice $0 You have been CTCP invited <gz>
    }
     }{
      //^notice $0 I am not in $3 or not oped
     }
    }
 }
 purge oc
}

on -ctcp "% % OPEN %" {
 gecho ${gc.ctcp}Channel Clear Request${cl} ${gc.inviteech}\($3\)${cl} from: ${gc.ctcpnk}$0${cl} $gc.peren\(${cl}$userhost()${gc.peren}\)${cl}
 if (ischannel($3)) {
  @ oc.found = rmatch($0!$userhost()$3 $_udb.cache)
    @ oc.idt = left(1 $userhost()) != [~]
    if (oc.found && (oc.idt || index(M $ch.flags[$%3]) >= 0 || index(M $_udb[$oc.found][flags]) >= 0) && index(IP $_udb[$oc.found][flags]) >= 0) {
     if (ischanop($N $3)) {
    if (key($3)) {/unlock $3}
    //mode $3 -l
    if (!onchannel($0 $3)) {
     //invite $0 $3
     //^notice $0 You have been CTCP invited <gz>
    }
     }{
      //^notice $0 I am not in $3 or not oped
     }
    }
 }
 purge oc
}


on -ctcp "% % UNBAN %" {
        gecho ${gc.ctcp}UNBAN Request${cl} \($3\) from: ${gc.ctcpnk}$0${cl} $gc.peren\(${cl}$userhost()${gc.peren}\)${cl}
    if (ischannel($3)) {
        @ oc.found = rmatch($0!$userhost()$3 $_udb.cache)
        @ oc.idt = left(1 $userhost()) != [~]
        if (oc.found && (oc.idt || index(M $ch.flags[$%3]) >= 0 || index(M $_udb[$oc.found][flags]) >= 0) && index(PU $_udb[$oc.found][flags]) >= 0) {
            if (ischanop($N $3)) {
                @ oc.ub = []
                fe ($chanmode($3 1)) oc.b {
                    if (match($0!$userhost() $oc.b) || match($oc.b $0!$userhost())) {
                        @ oc.ub = oc.ub ? [$oc.ub $oc.b] : oc.b
                    }
                }
                fe ($oc.ub) oc.b {
                    //mode $3 -b $oc.b
                }
                //^notice $0 removed all bans for you on $3 <gz>
            }{
                //^notice $0 I am not in $3 or not oped
            }
        }
    }
    purge oc
}
on -ctcp "% % WHOAMI*" {
 gecho ${gc.ctcp}Whoami Request${cl} from: ${gc.ctcpnk}$0${cl} $gc.peren\(${cl}$userhost()${gc.peren}\)${cl}
 fe ($mychannels()) oc.ch {
  @ oc.found = rmatch($0!$userhost()$oc.ch $_udb.cache)
  @ oc.idt = left(1 $userhost()) != [~]
  if (oc.found && (oc.idt || index(M $ch.flags[$%oc.ch]) >= 0 || index(M $_udb[$oc.found][flags]) >= 0) && index(ABIOP $_udb[$oc.found][flags]) >= 0) {
   //^notice $0 Mask '$_udb[$oc.found][mask] $_udb[$oc.found][chan]' flags $_udb[$oc.found][flags]\
  }
 }
 purge oc
}

on -ctcp "% % pass *" {
# gecho ${gc.ctcp}Password Change Accepted${cl} from: ${gc.ctcpnk}$0${cl} $gc.peren\(${cl}$userhost()${gc.peren}\)${cl}
 if ([$4]) {
  @ oc.found = rmatch($0\!$userhost()$3 $_udb.cache)
  if (oc.found) {
   if (_udb[$oc.found][descr]) {
    # we have a password already
    if (_udb[$oc.found][descr] == [$4]) {
     gecho ${gc.ctcp}Password CHANGE${cl} from: ${gc.ctcpnk}$0${cl} $gc.peren\(${cl}$userhost()${gc.peren}\)${cl}
     //^notice $0 Password Changed.
     @ _udb[$oc.found][descr] = [$5]
     /_save_userlist 1
    }{
     //^notice $0 Denied: Password or usage Incorrect.
     //^notice $0 Usage: /ctcp $N pass <channel> <oldpass> <newpass>
     gecho ${gc.ctcp}Password Change DENIED${cl} from: ${gc.ctcpnk}$0${cl} $gc.peren\(${cl}$userhost()${gc.peren}\)${cl}
    }
   }{
    gecho ${gc.ctcp}Password SET${cl} from: ${gc.ctcpnk}$0${cl} $gc.peren\(${cl}$userhost()${gc.peren}\)${cl}
    //^notice $0 Password Set.
    //^notice $0 To change: /ctcp $N pass <channel> <oldpass> <newpass>
    @ _udb[$oc.found][descr] = [$4]
    /_save_userlist 1
   }
  }{
   gecho ${gc.ctcp}Password Attempt${cl} from: ${gc.ctcpnk}$0${cl} $gc.peren\(${cl}$userhost()${gc.peren}\)${cl}
   //^notice $0 Denied: No access or usage Incorrect.
   //^notice $0 Usage: /ctcp $N pass <channel> <oldpass> <newpass>
  }
 }{
  @ oc.found = rmatch($0\!$userhost()$3 $_udb.cache)
  if (oc.found) {
   gecho ${gc.ctcp}Password Inquiry${cl} from: ${gc.ctcpnk}$0${cl} $gc.peren\(${cl}$userhost()${gc.peren}\)${cl}
   if (_udb[$oc.found][descr]) {
    //^notice $0 You have a password set for $3
    //^notice $0 To change: /ctcp $N pass <channel> <oldpass> <newpass>
   }{
    //^notice $0 You do not have a password set for $3
    //^notice $0 To Set: /ctcp $N pass <channel> <newpass>
   }
  }
 }
}

on -ctcp "% % help*" {
 gecho ${gc.ctcp}ctcp Help Request${cl} from: ${gc.ctcpnk}$0${cl} $gc.peren\(${cl}$userhost()${gc.peren}\)${cl}
 switch ($3) {
  (pass) {//^notice $0 To set:    /ctcp $N pass <#channel> <newpass>
          //^notice $0 To change: /ctcp $N pass <#channel> <oldpass> <newpass>
         }
  (whoami) {//^notice $0 Usage: /ctcp $N whoami -- shows you your userlist level and info}
  (invite) {//^notice $0 Usage: /ctcp $N invite <#channel> [<password>] -- invites you to specified channel}
  (op) {//^notice $0 Usage: /ctcp $N op <#channel> [<password>] -- ops you in specified channel}
  (voice) {//^notice $0 Usage: /ctcp $N voice <#channel> [<password>] -- voices you in specified channel}
  (clear) {//^notice $0 Usage: /ctcp $N clear <#channel> -- removes locks and limits on a channel}
  (open) {//^notice $0 Usage: /ctcp $N open <#channel> -- removes locks and limits on a channel}
  (unban) {//^notice $0 Usage: /ctcp $N unban <#channel> -- remove a ban on you in specified channel}
  (*) {//^notice $0 CTCP Commands available: OP INVITE PASS UNBAN WHOAMI CLEAR OPEN VOICE
       //^notice $0 For specific help: /ctcp $N help <topic>
      }
 }
}

alias _notify_uh {
    fe ($mychannels()) _ch {
        if (!onchannel($0 $_ch)) {
            @ _found = rmatch($0!$1$_ch $_udb.cache)
            if (_found && index(C $_udb[$_found][flags]) >= 0) {
                #if ( index(i $chanmode($_ch)) && ischanop($N $_ch) ) {
                    //invite $0 $_ch
                #}
            }
        }
    }
    //^assign -_ch
    //^assign -_found
}

^set input_prompt ▒▒▒▒▒▒▒▒▒░░░░░░░░░░░48% (Loading Userlist)
eval load $gzuserlist
#Channel Locks
alias _recreate_lock {
    //^assign -ch.rlock[$%0]
    //^assign -ch.flock[$%0]
    //^assign -ch.limit[$%0]
    //^assign -ch.key[$%0]
    @ _sign = [+]
    @ _parm = 1
    fec ($word(0 $ch.lock[$%0])) _c {
        switch ($_c) {
            (+) {@_sign = [+]}
            (-) {@_sign = [-]}
            (l) {
                if (_sign == [+]) {
                    //^assign -ch.limit[$%0]
                    @ ch.rlock[$%0] = strip(l $ch.rlock[$%0])
                    @ ch.flock[$%0] = strip(l $ch.flock[$%0])
                    if (word($_parm $ch.lock[$%0]) != []) {
                        @ ch.flock[$%0] #= [l]
                        @ ch.limit[$%0] = word($_parm $ch.lock[$%0])
                        @ _parm++
                    }
                }{
                    //^assign -ch.limit[$%0]
                    @ ch.flock[$%0] = strip(l $ch.flock[$%0])
                    @ ch.rlock[$%0] = strip(l $ch.rlock[$%0])
                    @ ch.rlock[$%0] #= [l]
                }
            }
            (k) {
                if (_sign == [+]) {
                    //^assign -ch.key[$%0]
                    @ ch.rlock[$%0] = strip(k $ch.rlock[$%0])
                    @ ch.flock[$%0] = strip(k $ch.flock[$%0])
                    if (word($_parm $ch.lock[$%0]) != []) {
                        @ ch.flock[$%0] #= [k]
                        @ ch.key[$%0] = word($_parm $ch.lock[$%0])
                        @ _parm++
                    }
                }{
                    //^assign -ch.key[$%0]
                    @ ch.flock[$%0] = strip(k $ch.flock[$%0])
                    @ ch.rlock[$%0] = strip(k $ch.rlock[$%0])
                    @ ch.rlock[$%0] #= [k]
                }
            }
            (n)(s)(t)(p)(m)(i) {
                if (_sign == [+]) {
                    @ ch.rlock[$%0] = strip($_c $ch.rlock[$%0])
                    @ ch.flock[$%0] = strip($_c $ch.flock[$%0])
                    @ ch.flock[$%0] #= [$_c]
                }{
                    //^assign -ch.key[$%0]
                    @ ch.flock[$%0] = strip($_c $ch.flock[$%0])
                    @ ch.rlock[$%0] = strip($_c $ch.rlock[$%0])
                    @ ch.rlock[$%0] #= [$_c]
                }
            }
        }
    }
}

alias askflood {
    setcset $0 $1\FLOOD_COUNT $("New value for messages \(Enter for $getcset($0 $1\FLOOD_COUNT)\): ")
    setcset $0 $1\FLOOD_TIME $("New value for seconds \(Enter for $getcset($0 $1\FLOOD_TIME)\): ")
    setcset $0 $1\FLOOD_DUPS $("New value for Dups \(Enter for $getcset($0 $1\FLOOD_DUPS)\): ")
    gecho Current sensors for $1\FLOOD are $getcset($0 $1\FLOOD_COUNT) msgs in $getcset($0 $1\FLOOD_TIME) seconds
}

# $0 == channel

alias asklock {
    @ _old_lock = ch.lock[$%0]
    @ _bah = [$("Mode lock for $0 \(Enter for ${_old_lock ? ['$_old_lock' OFF to remove] : [none]}\)")]
    if (_bah != []) {
        if (_bah == [off]) {
            //^assign -ch.lock[$%0]
            //^assign -ch.rlock[$%0]
            //^assign -ch.flock[$%0]
            //^assign -ch.limit[$%0]
            //^assign -ch.key[$%0]
        }{
            @ ch.lock[$%0] = _bah
            _recreate_lock $0
        }
    }
}

^set input_prompt ▒▒▒▒▒▒▒▒▒░░░░░░░░░░░49% (Userlist Code)


alias op {
 if (C) {
  if (ischanop($N $C)) {
   modeq.init
   fe ($*) _op.n {
    modeq.add_mode +o $_op.n
   }
   modeq.apply_modes $C
  }{
   gecho ${gc.errortopic}Doh! not oped on $C\. Use the force Luke...${cl}
  }
 }{
  gecho ${gc.errortopic} You are not on any channel in this window${cl}
 }
}


alias dop {
 if (C) {
  if (ischanop($N $C)) {
   modeq.init
   fe ($*) _do.n {
    modeq.add_mode -o $_do.n
   }
   modeq.apply_modes $C
  }{
   gecho ${gc.errortopic}Doh! not oped on $C\. Use the force Luke...${cl}
  }
 }{
  gecho ${gc.errortopic}You are not on any channel in this window${cl}
 }
}


alias deop dop $*

# $0 == flood type, returns ignore type

alias _ignore.type {
    @ function_return = [ALL]
    switch ($0) {
        (ACTION) {
            @ function_return = [ACTIONS]
        }
        (CTCP) {
            @ function_return = [CTCPS]
        }
        (MSG) {
            @ function_return = [MSGS]
        }
        (NOTICE) {
            @ function_return = [NOTICES]
        }
        (PUBLIC) {
            @ function_return = [PUBLIC]
        }
        (INVITE) {
            @ function_return = [INVITES]
        }
        (JOIN) (NICK) {
            @ function_return = [CRAP]
        }
        (WALLOP) {
            @ function_return = [WALLOPS]
        }
        (WALL) {
            @ function_return = [WALLS]
        }
        (*) {
            @ function_return = [ALL]
        }
    }
}

# $0 == flags   $1 == user@host
#
# Note that this alias is only used for non-channel related lookups, because
# when someone joins a channel, flags are cached anyway
#

alias _isflagset {
    @ function_return = 0
    @ _idt = left(1 $1) != [~]
    fe ($bmatches(*!*$1#* $_udb.cache)) _n {
        if (index($0 $_udb[$_n][flags]) >= 0 && (_idt || index(M $_udb[$_n][flags]) >= 0)) {
            @ function_return = 1
            //break
        }
    }
    ^assign -_n
}

alias _justhost {@ function_return = mid(${rindex(@ $0)+1} $@0 $0)}
alias _justuser {@ function_return = left($rindex(@ $0) $0)}


# $0 == ignored    $1 == type    $2 == nick    $3 == channel  $4 == data

on ^new_flood * {
 if ([$3]) {
  if (index(FP $nickdata($3 $2 2)) == -1 && N != ([$1]==[NICK] ? [$4] : [$2])) {
   modeq.init
   if (index(C $ch.flags[$%3]) >= 0 && ischanop($N $3)) {
    if (FLOOD_CHECK_HOST == [ON] && FLOOD_CHECK_USER == [OFF]) {
     modeq.addban_and_kick $3 *!*@$mask.host($_justhost($userhost())) <$1 flood>
    }{
     modeq.addban_and_kick $3 *!*$mask.userhost($userhost()) <$1 flood>
    }
    gecho Autobk for $2\ on $3\ for $1 flood
    @ _ig = _ignore.type($1)
    @ _uh = mask.userhost($userhost())
    if (([$1] == [DEOP] || [$1] == [NICK] !! [$1] == [KICK]) && [$2] ! = N) {
    }{
     if (!isignored($_ig $1 $userhost())) {
      gecho Autoignoring $2 for 3 minutes, $1 flood scanned on $2
      //^ignore *$_uh -t 180 $_ig
      //^assign -_ig
      //^assign -_uh
     }
    }
   }{
    @ _ig = _ignore.type($1)
    @ _uh = mask.userhost($userhost())
    if (!isignored($_ig $1 $userhost())) {
#     gecho Autoignoring $2 for 3 minutes, $1 flood scanned on $2
     if (([$1] == [DEOP] || [$1] == [NICK] !! [$1] == [KICK]) && [$2] ! = N) {
      gecho $1 flood scanned on $2
      if (ischanop($N $3)) {
       //kick $3 $2 <$1 flood>
      }
     }{
      gecho Autoignoring $2 for 3 minutes, $1 flood scanned on $2
      //^ignore *$_uh -t 180 $_ig
     }
     //^assign -_ig
     //^assign -_uh
    }
   }
   modeq.apply_modes $3
  }{
   gecho $1 flood scanned on $2
   if (index(FP $nickdata($3 $2 2)) == -1 && ischanop($N $C)) {
    if (([$1] == [DEOP] || [$1] == [NICK] || [$1] == [KICK]) && [$2] != N) {
     //kick $3 $2 $1 flood
    }
   }
  }
 }{
  if (!_isflagset(FP $userhost())) {
   if (([$1] == [DEOP] || [$1] == [NICK] || [$1] == [KICK]) && [$2] != N) {
    gecho $1 flood scanned on $2
   }{
    @ _ig = _ignore.type($1)
    @ _uh = mask.userhost($userhost())
    gecho Autoignoring $2 for 3 minutes, $1 flood
    //^ignore *$_uh -t 180 $_ig
    //^assign -_ig
    //^assign -_uh
   }
  }
 }
}

# Input: $0 == nick!user@host $1- list of channels
# returns list of channels with flags added, like #lice(OIFPUA)

alias _chans {
    @ _ch.new = []
    for ( @_ch.idx = 0, _ch.idx < [$#1-], @_ch.idx++) {
        @ _ch.found = rmatch($0$_stripop($word($_ch.idx $1-)) $_udb.cache)
        if (_ch.found) {
            @ _ch.new = _ch.new ? [$_ch.new $word($_ch.idx $1-)\($tolower($_udb[$_ch.found][flags])\)] : [$word($_ch.idx $1-)\($tolower($_udb[$_ch.found][flags])\)]
        }{
            @ _ch.new = _ch.new ? [$_ch.new $word($_ch.idx $1-)] : [$word($_ch.idx $1-)]
        }
    }
    @ function_return = _ch.new
    purge _ch
}

#
# Note that we keep channel /cset's in a separate structrure, so we can
# set/query them whenever we are on channel or no. /cset values will be
# copied to /cset when joined a channel in on join_me.
#

# $0 = channel, $1 = set name

alias getcset {
    @ function_return = cset($0 $1) ? cset($0 $1) : ch.cset[$%0][$1] ? ch.cset[$%0][$1] : [$($1)]
}

# $0 = channel, $1 = letter

alias isctog {
    @ function_return = index($1 $ch.flags[$%0]) >= 0
}

alias getctog {
    @ function_return = isctog($0 $1) ? [On] : [Off]
}

# $0 = channel, $1 = letter

alias togctog {
    /ctog $0 ${isctog($0 $1) ? [-$1] : [$1]}
}

alias togcset {
    @ ch.cset[$%0][$1] = getcset($0 $1) == [OFF] ? [ON] : [OFF]
    //^setcset $0 $1 $ch.cset[$%0][$1]
}

alias setcset {
    if ([$2]) {
        @ ch.cset[$%0][$1] = [$2]
        //^cset $0 $1 $2
    }
}

# $0 = channel, $1 = prefix like ACTION or CTCP
alias askflood {
    setcset $0 $1\FLOOD_COUNT $("New value for messages \(Enter for $getcset($0 $1\FLOOD_COUNT)\): ")
    setcset $0 $1\FLOOD_TIME $("New value for seconds \(Enter for $getcset($0 $1\FLOOD_TIME)\): ")
    gecho Current sensor for $1\FLOOD are $getcset($0 $1\FLOOD_COUNT) msgs in $getcset($0 $1\FLOOD_TIME) seconds
}

# $0 == #channel
#

alias all.chops.n {
    fe ($chanusers($C)) lala {
        if (ischanop($lala $C) && index(ABIOP $nickdata($C $lala 2)) == -1) {
            adduser -c $lala $C +NM
        }
    }
    ^assign -lala
}

#END USERLIST

/clear
gbecho  You are Funkin' With:
gbecho 07         04 ▒                                       ▒07
gbecho 07       04░▓█░█      08▄04▀▀░▀▀  ▄▄       ░   ▄    ▒ ▄ ▄▄▓▓▄■ ▀07
gbecho 07      04▐░▀▀▀▀▀▀  ▀ 08▒▀▀▀▀▀▀▄ ▄ 04▄▄░▄▄  ▄▄▀▀▀▀▀▒▀▀▀▀▀▀▓█07
gbecho 07 04▀ ■ ▄▓ 08▄▓▀▀▀▀▀▀▀▀  0F▄▄▄0B▄▄08 ▀▓▄▄▄▄▄▄▄▄▄▄▄▓▀▀▀▀▀▀▀▀▓▄ 04▓07
gbecho 07      04▓ 08▓ 0B▄▓▀░▒▓▓▄ ▓█ █▓░█  ▄▄▄▄▄▄▄▄▄▄  ▄▓▓▒░▀▓▄ 08█ 04▓07
gbecho 07      04▒ 08▓ 0B▓▓ ▄▄▄▄  ▓▒░▒▓▓░ ▒░ ░▒▒▓ ▒░▒░  ▄▄▄▄▄▓▓ 08█ 04▒07
gbecho 07      04░ 08▓ 0B▓█  ▓▓▓▓ ░▒▀▀▀▀  ▒░ ░░█▒ ▒█▒░ ▓▓▓▓▒ ▀▀ 08▓ 04░07
gbecho 07      04░ 08▓ 0B▓▒ ▐░▒▓█ █░ █░██ ██ ███░ ██░█ █▓▒░█ ▄▓ 08▓ 04░07
gbecho 07      04▒ 08▓ 03█▓▄██░░0B▓ 03██▄██▓█ █▓ ███▓ ███▒ ▓░░██▄▓█ 08█ 04░07
gbecho 07      04▓ 08▓  03▀▀▀▀▀▀   ▀▀▀▀▀  ▀▀ ▀▀▀▀ ▀▀▀▀  ▀▀▀▀▀▀  08█ 04▒07
gbecho 07      04█▄08▀▓▄▄▄▄▄▄▄▓▀▓▄▄▄▄▄▓▀▓▄▄▄▄▄▄▄▄▄▄▓▀▓▄▄▄▄▄▄▄▄▓ 04▓07
gbecho 07     04▐▒▒▄▄▄▄▄▄▄ ▄  ▄▄▄█▄▄▄ ▄  ▄ ▄░▄▄ ▄   ▄ ▄ ▄▄▄▄▄█▓▄▒07
gbecho 07    04■▀▒              ▒▀    ░     ▀▓      ░ jui▒ce▀▓█▓▀07
gbecho 07   04▀   09GemZ07 for 03OpenChat/204        ░                ▀07
gbecho 07                    0Fby07 0BGemini07 (0Agemini07@0Asilcom.com07)07
gbecho        Official GemZ site:  http://www.silcom.com/~gemini/gemz/
gbecho
eval if (beta) {
 gbecho 04*** 07This is a beta version of GemZ, send all bug reports to gemini 04***07
}

^set input_prompt ▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░50% (XDCC Subsystem)
##################################################
# XDCC Subsystem                                 #
# Written exclusively for OpenChat/2 by Gemini.  #
# I finally got rid of that lame xabi/fluff      #
# Vassago piece of junk                          #
##################################################

#################
#SAVED VARIABLES#
#################
@ gx = [\[gx\]]
@ gx.maxsends = 5
@ gx.maxsize = 320000
@ gx.maxqueue = 20
@ gx.maxtime = 480
@ gx.minspeed = 0
@ gx.ptime = 30
@ gx.savetime = 30

@ gx.autoget = 1
@ gx.autonotice = 0
@ gx.autopreview  = 0
@ gx.autosend = 1
@ gx.autoview = 0
@ gx.autosave = 1
@ gx.chansecurity = 0
@ gx.nickfile = 0
@ gx.notice = 1
@ gx.security = 0
@ gx.spiffyxdcc = 1
@ gx.pchannels = []
@ gx.xdcclog = 0
@ gx.uploaddir = [$exedir/download/]
@ gx.packfile = [$exedir/newxdcc.sav]
@ gx.secpass = [password]
@ gx.xdcclogfile = [$exedir/xdcc.log]

################################
#INTERNAL VARIABLES (NOT SAVED)#
################################
eval if (!xdcc.loaded) {
 @ xdcc.record = [0]
 @ xdcc.pcount = 1
 @ xdcc.scount = 1
}
@ xdcc.loaded = 1


######
#SETS#
######
^set DCC_BLOCK_SIZE 4096
^set DCC_BURST_MODE ON
^set DCC_REJECT_8BIT ON
^set DCC_REJECT_CHARS *?<>|
^set DCC_REJECT_CNTL ON

#################################
#XDCC INTERNAL SUPPORT FUNCTIONS#
#################################

###########################
# GemZ XDCC Api Functions #
###########################

alias dcc {
 if (([$0] == [send]) ||([$0] == [resend])){
  if (index(" $2-) >= 0) {
   //dcc $0 $1 $2- $gx.virtualdccfile($2-)
  }{
   //dcc $0 $1 "$2-" $gx.virtualdccfile($2-)
  }
 }{
  //dcc $*
 }
}

alias gx.virtualdccfile {
 fec ($file.sanspath($*)) _dc.c {
  if (_dc.c == [ ]) {@ _dc.r #= [_]}
  else if (_dc.c == ["]) {}
  else {@ _dc.r #= _dc.c}
 }
 @ function_return = _dc.r
 purge _dc
}


alias gx.getcount {@ function_return = xdcc._count(get)}
alias gx.sendcount {@ function_return = xdcc._count(send)}
alias gx.qcount {@ _xz.r = 0;foreach xdq _xz.i {@ _xz.r++};@ function_return = _xz.r;purge _xz}
alias gx.maxqueue {@ function_return = gx.maxqueue}
alias gx.maxsends {@ function_return = gx.maxsends}
alias gx.numpacks {@ function_return = xdcc.totpack}
alias gx.packdesc {@ function_return = xdp[$strip(# $0)][desc]}
alias gx.packnote {@ function_return = xdp[$strip(# $0)][note]}
alias gx.packpass {@ function_return = xdp[$strip(# $0)][pass]}
alias gx.packfiles {foreach xdp.$strip(# $0).files _f.n {@ _f.r #= _f.r ? [ ] ## xdp[$strip(# $0)][files][$_f.n] : xdp[$strip(# $0)][files][$_f.n]};@ function_return = _f.r;purge _f.r}
alias gx.packbytes {@ function_return = xdp[$strip(# $0)][bytes]}
alias gx.packcount {@ function_return = xdp[$strip(# $0)][count]}
alias gx.totaloffered {@ _xo.b = 0;for (@ _xo.i = 1, _xo.i <= gx.numpacks(), @ _xo.i++) {@ _xo.b += gx.packbytes($_xo.i)};@ function_return = _xo.b;purge _xo}
alias gx.totalsent {@ _xt.bs = 0;for (@ _xt.i = 1, _xt.i <= gx.numpacks(), @ _xt.i++) {@ _xt.bs += gx.packbytes($_xt.i) * gx.packcount($_xt.i)};@ function_return = _xt.bs;purge _xt}
alias gx.record {@ function_return = xdcc.record}
### GemZ XDCC Default Header/Footer Functions.
alias gx.nheader1 {@ function_return = [$gx  PACKS OFFERED  /msg $N xdcc list${gx.security ? [ <password>] : []} for listing]}
alias gx.nheader2 {@ function_return = gx.oheader2() ## [ [Rec: $xdcc.record\k/s]]}
alias gx.oheader1 {@ function_return = [$gx  PACKS OFFERED  /msg $N xdcc send # to receive pack.]}
alias gx.oheader2 {@ function_return = [$gx [ $gx.numpacks() ${gx.numpacks() != 1 ? [packs] : [pack]} ]  [${gx.maxsends - gx.sendcount()}\ of $gx.maxsends\ slots] [Queue: $gx.qcount()\/$gx.maxqueue\]}
alias gx.footer {@ function_return = [$gx [Rec: $xdcc.record\k/s] [Total: $gz.bytestomegs($gx.totaloffered()) MB] [Sent: $gz.bytestomegs($gx.totalsent()) MB]}
#Provided for compatability with Spiffy XDCC Replies.
alias xdcc.oldfooter {@ function_return = [$gx Total Offered: $gz.bytestomegs($gx.totaloffered()) MB  Total Grabbed: $gz.bytestomegs($gx.totalsent()) MB]}

alias gx.gettype {@ function_return = word(0 $dccitem($0))}
alias gx.getnick {@ function_return = word(1 $dccitem($0))}
alias gx.getstat {@ function_return = word(2 $dccitem($0))}
alias gx.gettime {@ function_return = word(3 $dccitem($0))}
alias gx.getoffset {@ function_return = word(4 $dccitem($0))}
alias gx.getread {@ function_return = word(5 $dccitem($0))}
alias gx.getsent {@ function_return = word(6 $dccitem($0))}
alias gx.getxfered {
    switch ($gx.gettype($0)) {
        (*GET) {@ function_return = word(6 $dccitem($0))}
        (*SEND) {@ function_return = word(5 $dccitem($0))}
    }
}
alias gx.getsize {@ function_return = word(7 $dccitem($0))}
alias gx.getfile {@ function_return = word(8 $dccitem($0))}
alias gx.getdccnum {@ function_return = word(9 $dccitem($0))}
alias gx.getserv {@ function_return = word(10 $dccitem($0))}

#takes in a dccitem index or dcc #
#returns raw number of seconds until dcc finishes based on current rate
alias gx.geteta {
    if (dccitem($0)) {
    ^set left on
        @ _ge[left] = gx.getsize($0) - (gx.getxfered($0) + gx.getoffset($0))
        ^set floating on
        @ _ge[left] = (_ge[left] * 100 ) / 1024
        ^set floating off
        @ function_return = gx.getrate($0) ? _ge[left] / gx.getrate($0) : -1
    ^set left off
    }
    else {@ function_return = 0}
    purge _ge
}

#takes in dccitem index or dcc #
#returns raw number of bytes per second
alias gx.getrate {
    @ function_return = dccitem($0) ? [${time() - gx.gettime($0) ? ((gx.getxfered($0) / ([${time() - gx.gettime($0)}])) * 100) / 1024 : 0}] : 0
}

#takes raw number of seconds, and formats it to look nice
alias gx.fixeta {
    if ([$0] == -1) {@ function_return = [N/A]}
    else {
    ^set left on
        @ _et[min] = ([$0] / 60) - (([$0] / 3600) * 60)
        @ _et[sec] = [$0] % 60
        if (@_et[sec]==1) {@ _et[sec] = [0$_et[sec]]}
        if (@_et[min]==1) {@ _et[min] = [0$_et[min]]}
        @ function_return = [${[$0] / 3600}:$_et[min]:$_et[sec]]
    ^set left off
    }
    purge _et
}

#takes raw number of bytest per second, and formats it to look nice
alias gx.fixrate {
    @ _t.r = [$0]
    if (@_t.r == 5) {@ _t.r = left(3 $_t.r)}
    else if (@_t.r==4) {@ _t.r = [$left(2 $_t.r)\.$[1]right(2 $_t.r)]}
    else if (@_t.r==3) {@ _t.r = [$left(1 $_t.r)\.$[2]right(2 $_t.r)]}
    else if (@_t.r==2) {@ _t.r = [0\.$_t.r]}
    else if (@_t.r==1) {@ _t.r = [0\.0$_t.r]}
    else {@ _t.r = [N/A]}
    @ function_return = _t.r
    ^assign -_t.r
}

alias gx.getperc {
    ^set float on
  ^set left on
    @ function_return = dccitem($0) && gx.getsize($0) ? [${(gx.getxfered($0) * 100) / gx.getsize($0)}] : [0.00]
  ^set left off
    ^set float off
    @ function_return = function_return ? function_return : [0.00]
}

alias gx.fixperc {@ function_return = [$[4]0%]}



#####################
# End Api Functions #
#####################
alias gxecho {
 if (gz.rows(XDCC n)) {
  xecho -window XDCC ${gc.gecho}■■■${cl} $gx ${gc.time}<$Z>${cl} $*
 }{
  xecho -target $T ${gc.gecho}■■■${cl} $gx $*
 }
}

alias xdcc.isoktopreview {if (match($right(4 $0) .tif .tga .ico .png .jpg .gif .tif .bmp)) {if ((!gx.autopreview) || (away)) {@ function_return = 1}}}

alias xdcc.log {
 if (gx.xdcclog) {
  @ _xl.h = open($gx.xdcclogfile W T)
  if (_xl.h != -1) {
   @ write($_xl.h \[$gz.getdate() $Z\] $*)
   @ close($_xl.h)
  }{
   gecho ${gc.errortopic}ERROR:${cl} Could not open xdcc log file $gx.xdcclogfile
  }
 }
}

alias xdcc.processrequest {
 if ((xdcc.validhost($2)) && (xdcc.chancheck($*))) {
  switch ($3) {
   (list)   {xdcc.listreq $0 $1 $2 $4-}
   (send)   {xdcc.sendreq $0 $1 $2 send $4-}
   (resend) {xdcc.sendreq $0 $1 $2 resend $4-}
   (help)   {xdcc.helpreq $0 $1 $2}
   (*)      {xdcc.unknownreq $0 $1 $2}
  }
 }
}
alias xdcc.unknownreq {evalserver $0 {.not $1 Unknown XDCC command: /msg $N xdcc help}}

alias xdcc.helpreq {
 if (gt.lasthelped != [$2]) {
  @ gt.lasthelped = [$2]
  ^timer -update 505 10 ^assign -gt.lasthelped;
  gxecho $1 \($2\) Requested xdcc Help
  evalserver $0 {.not $1 /msg $N xdcc list [#<N>] - to get the offered pack list.}
  evalserver $0 {.not $1 /msg $N xdcc send #<N> [<password>] - to send pack #<N>}
  evalserver $0 {.not $1 /msg $N xdcc resend #<N> [<password>] - to resend pack #<N>}
 # evalserver $0 {.not $1 /msg $N xdcc overview - to get Stats of current offers.}
 # evalserver $0 {.not $1 /msg $N xdcc queue - to get stats about your current Queue Position.}
 }
}

alias xdcc.passpack {@ function_return = xdp[$0][pass] ? [${xdp[$0][pass] == [$1]}] : 1}

alias xdcc.sendreq {
 @ _xs.p = strip(# $4)
#server, nick, userhost, send|resend, pack, password (if any)
 if (gx.sendcount() < gx.maxsends) {
  if (xdp[$_xs.p][files]) {
   if (xdcc.passpack($_xs.p $5)) {
    gxecho Sending #$_xs.p\ to $1\ \($2\)
    evalserver $0 {.not $1 Sending you $gx.packdesc($_xs.p) Which is \$#gx.packfiles($_xs.p)\ files\(s\) \[$gx.packbytes($_xs.p) bytes\]}
    @ xdp[$_xs.p][count]++
    for (@ _xs.i = 1, _xs.i <= xdp[$_xs.p][files], @ _xs.i++) {
     if (gx.sendcount() < gx.maxsends) {
      evalserver $0 {//^dcc $3 $1 $xdp[$_xs.p][files][$_xs.i]}
     }{
      evalserver $0 {.not $1 Send Limit reached, queueing: $file.sanspath($xdp[$_xs.p][files][$_xs.i])}
      xdcc.qfileadd $0 $1 $3 $xdp[$_xs.p][files][$_xs.i]
     }
    }
   }{
    gxecho Denied Send: $1 \($2\) [Attempted Password: $5]
    evalserver $0 {.not $1 You have specified the wrong password}
    evalserver $0 {.not $1 Format is /msg $N xdcc send <#packnum> <password>}
   }
  }{
   evalserver $0 {.not $1 Pack #$_xs.p does not exist.  /msg $N xdcc list}
  }
 }{
  if (xdp[$_xs.p][files]) {
   if (gx.qcount() < gx.maxqueue) {
    xdcc.qpackadd $0 $1 $3 $_xs.p
    evalserver $0 {.not $1 Send Limit reached, queueing: Pack #$_xs.p}
    evalserver $0 {.not $1 Pack will be sent when a slot opens up.}
    gxecho Queueing Pack #$_xs.p\ to $1\ \($2)\
   }{
    evalserver $0 {.not $1 Send limit \($gx.maxsends\) and Queue limit \($gx.maxqueue\) are full.  Try again later.}
   }
  }{
   evalserver $0 {.not $1 Pack #$_xs.p does not exist.  /msg $N xdcc list}
  }
 }
 purge _xs
}

alias xdcc.listreq {
 if (gx.security) {
  if ([$3]== gx.secpass) {
   if ([$4]) {
    xdcc.ulistspecific $0 $1 $2 $4
   }{
    @ xlr[$0][$%1] = servergroup($0)
    gxecho All pack list request from $1 \($2\)
   }
  }{
   evalserver $0 {.not $1 [gx] You do not have the Proper password}
   evalserver $0 {.not $1 [gx] Format is: /msg $N xdcc list <password> [<Pack Number>]}
  }
 }{
  if ([$3]) {
   xdcc.ulistspecific $*
  }{
   @ xlr[$0][$%1] = 1
   gxecho All pack list request from $1 \($2\)
  }
 }
}

alias xdcc.ulistspecific {
 @ _xu.n = strip(# $3)
 if (xdp[$_xu.n][files]) {
  gxecho List of pack #$_xu.n\ request received from $1 \($2\)
  evalserver $0 {.not $1 Pack $[2]_xu.n\:  $xdp[$_xu.n][desc]}
  evalserver $0 {.not $1 Length     File}
  for (@ _xu.i = 1, _xu.i <= xdp[$_xu.n][files], @ _xu.i++) {
   evalserver $0 {.not $1 $[10]fsize($xdp[$_xu.n][files][$_xu.i]) $xdp[$_xu.n][files][$_xu.i]}
  }
  evalserver $0 {.not $1 ---------- -------------------------------------------}
  evalserver $0 {.not $1 $[10]xdp[$_xu.n][bytes] $[2]xdp[$_xu.n][files] file(s) : $xdp[$_xu.n][count]\ Downloads}
 }{
  evalserver $0 {.not $1 pack #$_xu.n Does not exist.  /msg $N xdcc list}
 }
 purge _xu
}

alias xdcc.getchans {
 evalserver $0 fe ($mychannels()) _xm.c {if (match($_xm.c $1-)) {@ _xm.r #= [ $_xm.c]}}
 @ function_return = _xm.r
 purge _xm
}

alias xdcc.packsendto {
 fe ($*) _xc.n {if (_xc.r) {@ _xc.r #= [,$_xc.n]}{@ _xc.r = _xc.n}}
 @ function_return = _xc.r
 purge _xc
}

alias xdcc.psend {
 if ([$0]) {
  @ _xp.p = strip(# $0)
  if (xdp[$_xp.p][files]) {
   if (![$1]) {@ _xp.n = [$"Nicks to send to: "]}{@ _xp.n = [$1-]}
   fe ($_xp.n) _xp.c {
    xdcc.sendreq $lastserver() $_xp.c Manual-send send $_xp.p
    #xdcc.packsendto $lastserver() $_xp.c $_xp.p
   }
  }{gxecho Pack #$_xp.p Does not exist.}
 }{xdcc.psend $"[gxDCC] Enter Pack Number: "}
 purge _xp
}


alias xdcc.savecheck {
 if (gx.autosave) {
  if ((gx.savetime <= xdcc.scount) && (gx.savetime != 0)) {
   gxecho Autosaving Packlist after $gx.savetime minutes.
   xdcc.savepack
   @ xdcc.scount = 1
  }{@ xdcc.scount++}
 }
}

alias xdcc.ptimecheck {
 if (gx.autonotice) {
  if ((gx.ptime <= xdcc.pcount) && (gx.ptime != 0)) {
   if (gx.pchannels) {
    gxecho Autolist to \[$gx.pchannels \] after \$gx.ptime\ minutes.
    fe ($myservers(1)) _xp.s {
     @ _xp.c = xdcc.packsendto($xdcc.getchans($_xp.s $gx.pchannels))
     if (_xp.c) {
      if (gx.notice) {
       evalserver $_xp.s {xdcc.pnotify $_xp.s $_xp.c}
      }{
       evalserver $_xp.s {xdcc.plist $_xp.s $_xp.c}
      }
     }
    }
   }{
    xecho -target $T $gx WARNING: You don't have any offer channels set.  Pnotice Will NOT occur
   }
   @ xdcc.pcount = 1
  }{@ xdcc.pcount++}
 }
 purge _xp
}

alias xdcc.chancheck {
 @ _xc.r = 0
 if (gx.chansecurity) {
  evalserver $0 {fe ($mychannels()) _xc.c {if (match($1 $chanusers($_xc.c))) {@ _xc.r = 1;//break}}}
 }{@ _xc.r = 1}
 if (!_xc.r) {
  evalserver $0 {.not $1 Channel Security is on}
  gxecho Denied XDCC access: $1 \($2\) [Channel Security]
 }
 @ function_return = _xc.r
 purge _xc
}

alias xdcc.checkpaths {
 @ function_return = 0
 fe ($*) _x.s {
  if (findfiles(f $_x.s)) {
   @ function_return = 1
  }{
   @ _x.n = gx.uploaddir ## _x.s
   if (findfiles(f $_x.n)) {@ function_return = 1}
  }
 }
 purge _x
}

alias xdcc.findfiles {
 fe ($*) _x.s {
  if (findfiles(f $_x.s)) {
   fe ($findfiles(f $_x.s)) _x.rs {@ _x.r #= [ $_x.rs]}
  }{
   @ _x.nx = gx.uploaddir ## _x.s
   fe ($findfiles(f $_x.nx)) _x.rs {@ _x.r #= [ $_x.rs]}
  }
 }
 @ function_return = _x.r
 purge _x
}

alias xdcc._count {
 #should accept get/send/chat/raw
 @ _xd.count = 0
 for (@ _xd.idx = 0, _xd.item = dccitem($_xd.idx), @ _xd.idx++) {if (match(*$0 $word(0 $_xd.item))) {@ _xd.count++}}
 @ function_return = _xd.count
 purge _xd
}

alias xdcc.processlist {
 foreach xlr _xl.s {
  @ _xl.s = xdcc.getserver($_xl.s)
  if (_xl.s != -1) {
   foreach xlr.$_xl.s _xl.n {
    if (_xl.l) {@ _xl.l #= [,$decode($_xl.n)]}{@ _xl.l = decode($_xl.n)}
   }
   if (_xl.l) {xdcc.ulist $_xl.s $_xl.l}
  }
 }
 purge _xl
 purge xlr
}


#################
#QUEUE FUNCTIONS#
#################
alias xdcc.qlist {
 if (gx.qcount()) {
  gecho $gx NUM  Nick
  gecho $gx ==== ===========
  foreach xdq _xq.n {
   @ _xt[$xdq[$_xq.n][priority]] = _xq.n
  }
  foreach _xt _xq.m {
   gecho $gx $[-2]_xq.m\:  $[11]decode($_xt[$_xq.m])\ $xdq[$_xt[$_xq.m]][files] file(s)
   for (@ _xq.i = 1, _xq.i <= xdq[$_xt[$_xq.m]][files], @ _xq.i++) {
    gecho $gx         $xdq[$_xt[$_xq.m]][files][$_xq.i]
   }
  }
  purge _xq
  purge _xt
 }{
  gecho $gx The queue is empty.
 }
}

alias xdcc.qcancel {
 if ([$0]) {
  if (xdq[$%0][files]) {
   @ _xq.p = xdq[$%0][priority]
   gecho $gx $0 Canceled from the Queue
   purge xdq.$%0
   foreach xdq _xq.n {
    if (_xq.p < xdq[$_xq.n][priority]) {
     @ xdq[$_xq.n][priority] = xdq[$_xq.n][priority] - 1
    }
   }
  }{gecho $gx $0 does not exist in the XDCC Queue}
 }{gecho $gx Usage: /qcancel <nick>}
}


alias xdcc.filequeued {
 @ function_return = 0
 foreach xdq.$0.files _xf.i {if (xdq[$0][files][$_xf.i] == [$1]) {@ function_return = 1;//break}}
}

alias xdcc.qnotify {
 @ _xq.c = gx.qcount()
 if (_xq.c) {
  foreach xdq _xq.n {
   if ( (time() - xdq[$_xq.n][lnt]) >= (xdq[$_xq.n][priority] * 60) ) {
    @ xdq[$_xq.n][lnt] = time()
    @ _xq.s = xdcc.getserver($xdq[$_xq.n][srvn] $xdq[$_xq.n][srvg])
    if (_xq.s != -1) {
     evalserver $_xq.s {.not $decode($_xq.n) You are in Queue Position $xdq[$_xq.n][priority] of $_xq.c}
    }
   }
  }
 }
 purge _xq
}

alias xdcc.qfileadd {
#xdcc.qfileadd $0 $1 $3 $xdp[$_xs.p][files][$_xs.i]
#this should only be used to add single files to an existing queue
#server, nick, send|resend, file
 if (xdq[$%1][files]) {
  if (!xdcc.filequeued($%1 $word(3 $*))) {
   @ _xq.n = xdq[$%1][files] + 1
   @ xdq[$%1][files][$_xq.n]       = word(3 $*)
   @ xdq[$%1][files]               = _xq.n
   @ xdq[$%1][files][$_xq.n][type] = [$2]
  }
 }{
  #starting a new queue entry
  @ xdq[$%1][srvn]           = [$0]
  @ xdq[$%1][srvg]           = servergroup($0)
  @ xdq[$%1][files]          = 1
  @ xdq[$%1][files][1]       = word(3 $*)
  @ xdq[$%1][files][1][type] = [$2]
  @ xdq[$%1][priority]       = gx.qcount()
  @ xdq[$%1][onirc]          = 0
  @ xdq[$%1][lnt]            = 0
 }
 purge _xq
}

alias xdcc.qpackadd {
 foreach xdp.$3.files _xp.i {
  xdcc.qfileadd $0 $1 $2 $xdp[$3][files][$_xp.i]
 }
 purge _xp.i
}

alias xdcc.qpurge {
 gecho $gx queue purged
 purge xdq
}

alias xdcc.qwaspopped {
 foreach xdq _xq.n {
  @ xdq[$_xq.n][priority] = xdq[$_xq.n][priority] - 1
  if (xdq[$_xq.n][priority] == 0) {
   purge xdq.$_xq.n
  }
 }
}

alias xdcc.qpop {
 foreach xdq _xq.n {
  if (xdq[$_xq.n][priority] == 1) {
   #get the server to send it to
   @ _xq.s = xdcc.getserver($xdq[$_xq.n][srvn] $xdq[$_xq.n][srvg])
   if (_xq.s == -1) {
    if (xdq[$_xq.n][onirc] = 5) {
     purge xdq.$_xq.n
     xdcc.qwaspopped
    }{
     @ xdq[$_xq.n][onirc] = xdq[$_xq.n][onirc] + 1
    }
   }{
    gxecho Offering Queued file \($xdq[$_xq.n][files][1]\) to $decode($_xq.n)\
    evalserver $_xq.s {.not $decode($_xq.n) Sending Queued file: $xdq[$_xq.n][files][1]}
    evalserver $_xq.s {//^dcc $xdq[$_xq.n][files][1][type] $decode($_xq.n) "$xdq[$_xq.n][files][1]"}
    if (xdq[$_xq.n][files] == 1) {
     purge xdq.$_xq.n
     xdcc.qwaspopped
    }{
     for (@ _xq.idx = 1, _xq.idx < xdq[$_xq.n][files], @ _xq.idx++) {
      @ xdq[$_xq.n][files][$_xq.idx][type] = xdq[$_xq.n][files][${_xq.idx+1}][type]
      @ xdq[$_xq.n][files][$_xq.idx] = xdq[$_xq.n][files][${_xq.idx+1}]
     }
     @ _xq.idx--
     @ xdq[$_xq.n][files] = _xq.idx
     ^assign xdq[$_xq.n][files][$_xq.idx]
    }
   }
  //break
  }
 }
 purge _xq
}

alias xdcc.validhost {@ function_return = 1}

#takes a servernum, if connected returns same number
#also takes servergroup, if servernum is not connected, then
#will return first connected server in servergroup.
#returns < 1 if can't find such a beast
alias xdcc.getserver {
 @ function_return = -1
 if (isconnected($0)) {@ function_return = [$0]}
 else {
  for (@ _xs.srv=0, servername($_xs.srv), @_xs.srv++) {
   if (servergroup($_xs.srv) == [$1]) {
    if (isconnected($_xs.srv)) {
     @ function_return = _xs.srv
     //break
    }
   }
  }
 }
 purge _xs
}

#############################
#Pack Setup and Notification#
#############################
alias xdcc.addpchan {
 if ([$0]) {
  fe ($*) _xp.i {
   if (!match($_xp.i $gx.pchannels)) {@ gx.pchannels #= [ $_xp.i]}
  }
  gecho $gx New channel Autolist Channels: $gx.pchannels
  makexdccmenu
 }{
  @ _xp.n = [$"[gxDCC] Enter new channel(s): "]
  if (_xp.n) {xdcc.addpchan $_xp.n}
 }
 purge _xp
}

alias xdcc.removepchan {
 if ([$0]) {
  @ gx.pchannels = stripw($0 $gx.pchannels)
  makexdccmenu
  gecho $gx $0 removed from Autolist channels
 }
}


alias xdcc.pnotify {
 if (xdcc.totpack) {
  evalserver $0 {saysend $1 $gx.nheader1()}
  evalserver $0 {saysend $1 $gx.nheader2()}
 }
}

alias xdcc.plist {
# $0 is server, $1 is list of channels to send list to
 if (xdcc.totpack) {
  evalserver $0 {saysend $1 $gx.oheader1()}
  evalserver $0 {saysend $1 $gx.oheader2()}
  for (@ _xl.i = 1, _xl.i <= xdcc.totpack, @ _xl.i++) {
   @ _xl.it = [#]##[$_xl.i]
   @ _xl.b = gz.fixbytes($xdp[$_xl.i][bytes])
   @ _xl.f = xdp[$_xl.i][files]
   if (xdp[$_xl.i][pass]) {@ _xl.p = [[pass] ]}{@ _xl.p = [ ]}
   evalserver $0 {saysend $1 $[-3]_xl.it\ $[-3]xdp[$_xl.i][count]\x [\$[-4]_xl.b\][\$[-2]_xl.f\]$_xl.p$xdp[$_xl.i][desc]}
   if (xdp[$_xl.i][note]) {
    evalserver $0 {saysend $1  ^- $xdp[$_xl.i][note]}
   }
  }
  evalserver $0 {saysend $1 $gx.footer()}
  purge _xl
 }{gecho $gx No files offered}
}

alias xdcc.ulist {
# $0 should be server to send list to, $1 should be list of nicks to send list to.
  if (xdcc.totpack) {
      if (gz.srvtargets()) {
          csq.aqueue $0 .not $1 $gx.oheader2()
    }{
          fe ($gz.unparse($1)) _tl {
              csq.aqueue $0 .not $_tl $gx.oheader2()
            }
        }
  for (@ _xl.i = 1, _xl.i <= xdcc.totpack, @ _xl.i++) {
   @ _xl.it = [#]##[$_xl.i]
   @ _xl.b = gz.fixbytes($xdp[$_xl.i][bytes])
   @ _xl.f = xdp[$_xl.i][files]
   if (xdp[$_xl.i][pass]) {@ _xl.p = [[pass] ]}{@ _xl.p = [ ]}
#   evalserver $0 {.not $1 $gx $[-3]_xl.it\ $[-3]xdp[$_xl.i][count]\x [\$[-4]_xl.b\][\$[-2]_xl.f\]$_xl.p$xdp[$_xl.i][desc]}
    csq.aqueue $0 .not $1 $gx $[-3]_xl.it\ $[-3]xdp[$_xl.i][count]\x [\$[-4]_xl.b\][\$[-2]_xl.f\]$_xl.p$xdp[$_xl.i][desc]
   if (xdp[$_xl.i][note]) {
    if (gz.srvtargets()) {
          csq.aqueue $0 .not $1 $::gx  ^- $xdp[$_xl[i]][note]
        }{
             fe ($gz.unparse($1)) _tl {
               csq.aqueue $0 .not $_tl $::gx  ^- $xdp[$_xl[i]][note]
            }
    }
   }
  }
          if (gz.srvtargets()) {
            csq.aqueue $0 .not $1 $xdcc.oldfooter()
        }{
            fe ($gz.unparse($1)) _tl {
                csq.aqueue $0 .not $_tl $xdcc.oldfooter()
            }
        }
 purge _xl
 }{
         if (gz.srvtargets()) {
            csq.aqueue $0 .not $1 No files offered.
        }{
            fe ($gz.unparse($1)) _tl {
                csq.aqueue $0 .not $_tl No files offered.
            }
        }

}
}

alias xdcc.checksends {
 for (@ _cs.i = 0, _cs.d = dccitem($_cs.i), @ _cs.i++) {
  if (match(*send $word(0 $_cs.d))) {
   @ _cs.et = time() - word(3 $_cs.d)
   @ _cs.mt = gx.maxtime * 60
   if ((_cs.et > _cs.mt) && (gx.maxtime != 0)) {
    gxecho Send to $word(1 $_cs.d) \($word(8 $_cs.d)\) Clamp Timed out.
    evalserver $word(10 $_cs.d) {//^notice $word(1 $_cs.d) $gx.maxtime minute clamp Timeout: $word(8 $_cs.i)}
    //dcc close $word(9 $_cs.d)
   }
   else if ((_cs.et > 240) && (word(2 $_cs.d) == [Waiting])) {
    gxecho Send to $word(1 $_cs.d) \($word(8 $_cs.d)\) Timed out.
    evalserver $word(10 $_cs.d) {//^notice $word(1 $_cs.d) 4 Minute Timeout: $file.sanspath($word(8 $_cs.d))}
    //dcc close $word(9 $_cs.d)
   }
   else if ((_cs.et > 60) && (word(2 $_cs.d) == [Waiting])) {
    evalserver $word(10 $_cs.d) {//^notice $word(1 $_cs.d) DCC Pending: \($file.sanspath($word(8 $_cs.d))\) Type /DCC GET $N\.}
   }
  }
 }
 purge _cs
}

############
#pack setup#
############
alias xdcc.savepack {
 if ([$0]) {
  @ _xs.h = open($0 W D T)
  gxecho Saving file... $0
 }{
  @ _xs.h = open($gx.packfile W D T)
  gxecho Saving Default file... $gx.packfile
 }
 @ write($_xs.h GemZ XDCC Save File)
 for (@ _xs.idx = 1, _xs.idx <= xdcc.totpack, @ _xs.idx++) {
  @ write($_xs.h PACK $_xs.idx)
  @ write($_xs.h desc $xdp[$_xs.idx][desc])
  @ write($_xs.h note $xdp[$_xs.idx][note])
  @ write($_xs.h pass $xdp[$_xs.idx][pass])
  @ write($_xs.h count $xdp[$_xs.idx][count])
  for (@ _xs.idx2 = 1, _xs.idx2 <= xdp[$_xs.idx][files], @ _xs.idx2++) {
   @ write($_xs.h file $xdp[$_xs.idx][files][$_xs.idx2])
  }
 }
 @ close($_xs.h)
 purge _xs
}

alias xdcc.loadpack {
 purge xdp
 @ xdcc.totpack = 0
 if ([$0]) {
  @ _xo.h = open($0 R T)
  gxecho Loading XDCC Offer file: $0
 }{
  @ _xo.h = open($gx.packfile R T)
  gxecho Loading XDCC Offer file: $gx.packfile
 }
 @ _xo.l = read($_xo.h)
 while ([$eof($_xo.h)] == [0]) {
  @ _xo.l = read($_xo.h)
  switch ($word(0 $_xo.l)) {
   (PACK) {@ xdcc.totpack++;@ _xo.files = 0}
   (desc) {@ xdp[$xdcc.totpack][desc] = ref(2-#_xo.l+1 $_xo.l)}
   (note) {@ xdp[$xdcc.totpack][note] = ref(2-#_xo.l+1 $_xo.l)}
   (pass) {@ xdp[$xdcc.totpack][pass] = ref(2-#_xo.l+1 $_xo.l)}
   (count) {@ xdp[$xdcc.totpack][count] = ref(2-#_xo.l+1 $_xo.l)}
   (file) {
     if (fexist($word(1 $_xo.l))== 1) {
      @ _xo.files++
      @ xdp[$xdcc.totpack][files] = _xo.files
      @ xdp[$xdcc.totpack][files][$_xo.files] = ref(2=#_xo.l+1 $_xo.l)
      @ xdp[$xdcc.totpack][bytes] = xdp[$xdcc.totpack][bytes] + fsize($word(1 $_xo.l))
     }{
      gxecho Missing file : $word(1 $_xo.l)
     }
    }
   (*) {}
  }
 }
 @ close($_xo.h)
 purge _xo
}

#alias xdcc.dialogoffer

alias xdcc.offer {
 if ([$0]) {
  @ _tmp.files = [$*]
 }{
  @ _tmp.files = [$"[gxDCC] Files: "]
 }
 if (xdcc.checkpaths($_tmp.files)) {
  @ xdcc.totpack++
  @ _tmp.numfiles = 0
  fe ($xdcc.findfiles($_tmp.files)) _tmp._file {
   @ _tmp.numfiles++
   @ xdp[$xdcc.totpack][files][$_tmp.numfiles] = _tmp._file
   @ xdp[$xdcc.totpack][bytes] = xdp[$xdcc.totpack][bytes] + fsize($_tmp._file)
  }
  @ xdp[$xdcc.totpack][files] = _tmp.numfiles
  @ xdp[$xdcc.totpack][desc] = [$"[gxDCC] Description: "]
  @ xdp[$xdcc.totpack][note] = [$"[gxDCC] Note: "]
  @ xdp[$xdcc.totpack][pass] = [$"[gxDCC] Password: "]
  @ xdp[$xdcc.totpack][count] = 0
  gecho $gx $_tmp.numfiles\ file\(s\) added to Pack #$xdcc.totpack\.
 }{
  gecho $gx One or more of these files don't exist.
 }
 purge _tmp
}

alias xdcc.doffer {
 if ([$0]==[]) {
  @ _tmp = [$"[gxDCC] Pack to remove (* for all): "]
 }{
  @ _tmp = strip(# $0)
 }
 if (_tmp == [*]) {
  gecho $gx All packs removed from offer list.
  purge xdp
  @ xdcc.totpack = 0
 }{
  if (_tmp) {
   if (xdp[$_tmp][files] || xdp[$_tmp][desc]) {
    #//purge xdp.$_tmp
    xdcc.delpackbynum $_tmp
    gecho $gx pack #$_tmp Removed
   }{
    gecho $gx pack $0 does not exist
   }
  }
 }
 ^assign -_tmp
}

alias xdcc.delpackbynum {
 for (@ _xn.i = [$0], _xn.i < xdcc.totpack, @ _xn.i++) {
  purge xdp.$_xn.i
  @ xdp[$_xn.i][files] = xdp[${_xn.i +1}][files]
  @ xdp[$_xn.i][desc] = xdp[${_xn.i +1}][desc]
  @ xdp[$_xn.i][pass] = xdp[${_xn.i +1}][pass]
  @ xdp[$_xn.i][note] = xdp[${_xn.i +1}][note]
  @ xdp[$_xn.i][count] = xdp[${_xn.i +1}][count]
  @ xdp[$_xn.i][bytes] = xdp[${_xn.i +1}][bytes]
  for (@ _xn.a = 1, _xn.a <= xdp[$_xn.i][files], @ _xn.a++) {
   @ xdp[$_xn.i][files][$_xn.a] = xdp[${_xn.i +1}][files][$_xn.a]
  }
 }
 purge xdp.$xdcc.totpack
 @ xdcc.totpack--
 purge _xn
}

alias xdcc.file {
 if ([$0]) {
  @ _xf.p = strip(# $0)
  if (_xf.p) {
   @ _xf.files = [$"[gxDCC] Files: "]
   if (xdcc.checkpaths($_xf.files)) {
    @ _xf.numfiles = 0
    @ xdp[$_xf.p][bytes] = 0
    fe ($xdcc.findfiles($_xf.files)) _xf._file {
     @ _xf.numfiles++
     @ xdp[$_xf.p][files][$_xf.numfiles] = _xf._file
     @ xdp[$_xf.p][bytes] = xdp[$_xf.p][bytes] + fsize($_xf._file)
    }
    @ xdp[$_xf.p][files] = _xf.numfiles
    gecho $gx $_xf.numfiles Added to pack #$_xf.p
   }{
    gecho $gx One or more of these files does not exist.
   }
  }{
   gecho $gx Pack #$_xf.p doesn't exist
  }
 }{
  @ _xf.n = [$"[gxDCC] Enter Pack number: "]
  if (_xf.n) {xdcc.desc $_xf.n}
 }
 purge _xf
}

alias xdcc.desc {
 if ([$0]) {
  @ _xf.p = strip(# $0)
  if (xdp[$_xf.p][files]) {
   gecho $gx Changing Description for pack #$_xf.p
   @ xdp[$_xf.p][desc] = [$"[gxDCC] Enter New Description: "]
  }{gecho $gx Pack #$_xf.p doesn't exist}
 }{
  @ _xf.n = [$"[gxDCC] Enter Pack number: "]
  if (_xf.n) {xdcc.desc $_xf.n}
 }
 purge _xf
}

alias xdcc.note {
 if ([$0]) {
  @ _xf.p = strip(# $0)
  if (xdp[$_xf.p][files]) {
   gecho $gx Changing Note for pack #$_xf.p
   @ xdp[$_xf.p][note] = [$"[gxDCC] Enter New Note: "]
  }{gecho $gx Pack #$_xf.p doesn't exist}
 }{
  @ _xf.n = [$"[gxDCC] Enter Pack number: "]
  if (_xf.n) {xdcc.note $_xf.n}
 }
 purge _xf
}

alias xdcc.pass {
 if ([$0]) {
  @ _xf.p = strip(# $0)
  if (xdp[$_xf.p][files]) {
   gecho $gx Changing Password for pack #$_xf.p
   @ xdp[$_xf.p][pass] = [$"[gxDCC] Enter New Password: "]
  }{gecho $gx Pack #$_xf.p doesn't exist}
 }{
  @ _xf.n = [$"[gxDCC] Enter Pack number: "]
  if (_xf.n) {xdcc.pass $_xf.n}
 }
 purge _xf
}

alias xdcc.list {
 if (xdcc.totpack) {
  if (![$0]) {
   gecho $gx $gx.oheader2()
   for (@ _xl.i = 1, _xl.i <= xdcc.totpack, @ _xl.i++) {
    @ _xl.it = [#]##[$_xl.i]
    @ _xl.b = gz.fixbytes($xdp[$_xl.i][bytes])
    @ _xl.f = xdp[$_xl.i][files]
    if (xdp[$_xl.i][pass]) {@ _xl.p = [[pass] ]}{@ _xl.p = [ ]}
    gecho $gx $[-3]_xl.it\ $[-3]xdp[$_xl.i][count]\x [\$[-4]_xl.b\][\$[-2]_xl.f\]$_xl.p$xdp[$_xl.i][desc]
    if (xdp[$_xl.i][note]) {gecho $gx  ^- $xdp[$_xl.i][note]}
   }
   gecho $gx $gx.footer()
   purge _xl
  }{xdcc.listspecific $*}
 }{gecho $gx No files offered}
}

alias xdcc.maxtime {
 if ([$0] != []) {
  if ([$0] < 4) {
   gecho $gx Maxtime must be greater than 4 minutes, and cannot be 0.
   gecho $gx Suggest leaving a high number, such as 480minutes (8 hours)
  }{
   @ gx.maxtime = [$0]
   @menucontrol(&xdcc &52 text Max. Send Time    [$gx.maxtime min])
  }
 }{
  @ _xp.t = [$"[gxDCC] Enter New Maximum transfer time: "]
  if (_xp.t != []) {xdcc.maxtime $_xp.t}
 }
 purge _xp
}

alias xdcc.limit {
 if ([$0] != []) {
  @ gx.maxsends = [$0]
  @menucontrol(&xdcc &50 text Max. Sends    [$gx.maxsends])
 }{
  @ _xp.t = [$"[gxDCC] Enter New Send Limit: "]
  if (_xp.t != []) {xdcc.limit $_xp.t}
 }
 purge _xp
}


alias xdcc.qmax {
 if ([$0] != []) {
  @ gx.maxqueue = [$0]
  @menucontrol(&xdcc &51 text Max. Queued    [$gx.maxqueue])
 }{
  @ _xp.t = [$"[gxDCC] Enter New Maximum Queue size: "]
  if (_xp.t != []) {xdcc.qmax $_xp.t}
 }
 purge _xp
}

alias xdcc.autoget {
 if ( ([$0]) && (match($0 ON OFF)) ) {
  @ gx.autoget = _bool($0)
  @ menucontrol(&xdcc &1 check $gx.autoget)
 }{gecho Usage: /xdcc autoget ON | OFF}
}

alias xdcc.autosend {
 if ( ([$0]) && (match($0 ON OFF)) ) {
  @ gx.autosend = _bool($0)
  @ menucontrol(&xdcc &2 check $gx.autosend)
 }{gecho Usage: /xdcc autosend ON | OFF}
}

alias xdcc.autosave {
 if ( ([$0]) && (match($0 ON OFF)) ) {
  @ gx.autosave = _bool($0)
  @ menucontrol(&xdcc &3 check $gx.autosave)
 }{gecho Usage: /xdcc autosave ON | OFF}
}

alias xdcc.logfile {
 if ([$0]) {
  @ gx.xdcclogfile = gz.fixpath($0)
  @ menucontrol(&xdcc &103 text XDCC Log File    [$gx.xdcclogfile])
  gecho $gx XDCC log file set to: $gx.xdcclogfile
 }{
  @ _dl.d = [$"[gxDCC] Enter new XDCC Log File Directory: "]
  if (_dl.d) {xdcc.logfile $_dl.d}
 }
 purge _dl
}


alias xdcc.dldir {
 if ([$0]) {
  @ _dl.d = gz.striplastslash($gz.fixpath($0))
  if (findfiles(d $_dl.d)) {
   //^set DCC_DLDIR $_dl.d
   @ menucontrol(&xdcc &100 text Download Dir    [$DCC_DLDIR])
  }{
   gecho $gx Invalid Directory specified.
  }
  gecho $gx Download Directory Set to: $DCC_DLDIR
 }{
  @ _dl.d = [$"[gxDCC] Enter new Download Directory: "]
  if (_dl.d) {xdcc.dldir $_dl.d}
 }
 purge _dl
}

alias xdcc.uldir {
 if ([$0]) {
  @ _dl.d = gz.striplastslash($gz.fixpath($0))
  if (findfiles(d $_dl.d)) {
   @ gx.uploaddir = _dl.d ## [/]
   @ menucontrol(&xdcc &102 text Upload Dir    [$gx.uploaddir])
  }{
   gecho $gx Invalid Directory specified.
  }
  gecho $gx Upload Directory Set to: $gx.uploaddir
 }{
  @ _dl.d = [$"[gxDCC] Enter new Upload Directory: "]
  if (_dl.d) {xdcc.uldir $_dl.d}
 }
 purge _dl
}


alias xdcc.ptime {
 if ([$0] != []) {
  @ gx.ptime = [$0]
  @menucontrol(&xdcc &54 text Autolist Time    [$gx.ptime min])
 }{
  @ _xp.t = [$"[gxDCC] Enter New Autolist time: "]
  if (_xp.t != []) {xdcc.ptime $_xp.t}
 }
 purge _xp
}

alias xdcc.password {
 if ([$0] != []) {
  @ gx.secpass = [$0]
  @menucontrol(&xdcc &56 text List Sec. Password    [$left($@gx.secpass $gt.poptmp)])
 }{
  @ _xp.pw = [$"[gxDCC] Enter New List security password: "]
  if (_xp.pw != []) {xdcc.password $_xp.pw}
 }
 purge _xp
}


alias xdcc.savetime {
 if ([$0] != []) {
  @ gx.savetime = [$0]
  @menucontrol(&xdcc &55 text Autosave Time    [$gx.savetime min])
 }{
  @ _xp.t = [$"[gxDCC] Enter New Autosave time: "]
  if (_xp.t != []) {xdcc.savetime $_xp.t}
 }
 purge _xp
}

alias xdcc.minspeed {
 if ([$0] != []) {
  @ gx.minspeed = [$0]
  @menucontrol(&xdcc &53 text Min. Speed    [$gx.minspeed k/s])
 }{
  @ _xp.t = [$"[gxDCC] Enter New Minspeed (k/s): "]
  if (_xp.t != []) {xdcc.minspeed $_xp.t}
 }
 purge _xp
}


alias xdcc.listspecific {
 @ _xl.i = strip(# $0)
 if (xdp[$_xl.i][files]) {
  gecho $gx Information for Pack #$_xl.i
  gecho $gx DESC: $xdp[$_xl.i][desc]
  if (xdp[$_xl.i][note]) {gecho $gx NOTE: $xdp[$_xl.i][note]}
  if (xdp[$_xl.i][pass]) {gecho $gx PASS: $xdp[$_xl.i][pass]}
  for (@ _xl.si = 1, _xl.si <= xdp[$_xl.i][files], @ _xl.si++) {
   gecho $gx FILE: $xdp[$_xl.i][files][$_xl.si]
  }
  gecho $gx Total: $xdp[$_xl.i][bytes] Bytes on $xdp[$_xl.i][files] file(s) : $xdp[$_xl.i][count] snags
 }{gecho $gx Pack #$_xl.i doesn't exist.}
 purge _xl
}

alias xdcc.qcheck {
 if ((gx.sendcount() < gx.maxsends) && (gx.qcount())) {
  if (gx.qcount() < gx.maxqueue) {xdcc.qpop}
 }
}

alias xdcc.qtimer {
 xdcc.qcheck
 xdcc.processlist
 ^timer -update 319 10 xdcc.qtimer
}

alias xdcc.savesettings {
 @ write($0 ###XDCC SETTINGS)
 foreach gx _gx.i {@ write($0 @ gx.$tolower($_gx.i) = [$(gx.$_gx.i)])}
 @ write($0 //set DCC_DLDIR $DCC_DLDIR)
 purge _gx
}


#Finishing loads/setup
xdcc.qtimer

#
alias _doget {
 @ do.found = -1
 for ( @ do.idx = 0, do.item = dccitem($do.idx), @ do.idx++) {
  if (word(2 $do.item) == [offered]) {@ do.found = do.idx}
 }
 if (do.found != -1) {
  @ do.item = dccitem($do.found)
  switch ($word(0 $do.item)) {
   (GET) {//dcc get $word(9 $do.item)}
   (REGET) {//dcc reget $word(9 $do.item)}
   (CHAT) {//dcc chat $word(9 $do.item)}
  }
 }{gecho $gx No dcc connections offered}
}

alias _doclose {
 @ do.found = -1
 for ( @ do.idx = 0, do.item = dccitem($do.idx), @ do.idx++) {
  if (word(2 $do.item) == [offered]) {@ do.found = do.idx}
 }
 if (do.found != -1) {
  @ do.item = dccitem($do.found)
  //dcc close $word(9 $do.item)
 }{gecho $gx No dcc connections offered}
}

alias _doresume {
 @ do.found = -1
 for ( @ do.idx = 0, do.item = dccitem($do.idx), @ do.idx++) {
  if (word(2 $do.item) == [offered] && word(0 $do.item) == [GET]) {
   @ do.found = do.idx
  }
 }
 if (do.found != -1) {
  @ do.item = dccitem($do.found)
  //dcc resume $word(9 $do.item)
 }{gecho $gx No dcc connections offered}
}

alias _try_rename {
 @ function_return = 0
 # first try just add .bak to a filename, should work on HPFS
 @ unlink($0\.bak)
 if (!rename($0 $0\.bak)) {
  @ function_return = [$0\.bak]
 }{
  # if failed, to some more parsing, and determnate file's extention and
  # replace it with .bak
  @ _file = file.sansext($_file)
  @ unlink($_file\.bak)
  if (!rename($0 $_file\.bak)) {@ function_return = [$_file\.bak]}
  //^assign -_file
 }
}
##########
#ON HOOKS#
##########

on ^msg "% XDCC *" {xdcc.processrequest $lastserver() $0 $userhost() $2-}
on ^ctcp "% % XDCC *" {xdcc.processrequest $lastserver() $0 $userhost() $3-}

^on #^timer 319 * {
 xdcc.qnotify
 xdcc.checksends
 xdcc.ptimecheck
 xdcc.savecheck
}

^on ^dcc_connect "% % *GET*" {
 gz.playsnd getconnect
 if ((gx.autopreview) && (!away)) {previewbynum $0}
 gxecho DCC \$2\ connection to ${gc.nick}$1${cl} ${gc.peren}\(${cl}$3\,$4${gc.peren}\)${cl} established
 if ([$5]) {gxecho DCC \$2\ established at $5-}
}
^on ^dcc_connect "% % *SEND*" {
 gz.playsnd sendconnect
 gxecho DCC \$2\ connection to ${gc.nick}$1${cl} ${gc.peren}\(${cl}$3\,$4${gc.peren}\)${cl} established
 if ([$5]) {gxecho DCC \$2\ established at $5-}
}
^on ^dcc_connect "% % *CHAT*" {
 gz.playsnd chatconnect
 gxecho DCC \$2\ connection to ${gc.nick}$1${cl} ${gc.peren}\(${cl}$3\,$4${gc.peren}\)${cl} established
}

^on #-dcc_connect 23 "*" {^hook dccchanged;if ([$autodccst]==[ON] && [$gt.statbar]==[Normal]) {statgl}}
^on #-dcc_connect 33 "#% % CHAT % *" {if (gz.autochat && !chanwindow(=$1)) {/chat $1}}
^on #-dcc_lost 23 "*" {^timer 1 xdcc.qcheck;^timer 1 ^hook dccchanged}
^on #-dcc_request 23 "*" {^hook dccchanged}

^on ^dcc_lost -"*SEND % COMPLETED*"

^on ^dcc_lost "*SEND * COMPLETED*" {
 gz.playsnd dccsendfin
 gxecho DCC \$2\ ${gc.peren}\(${cl}$ref(4-${gz.strwords($*) - 2} $*)${gc.peren}\)${cl} to ${gc.nick}$1${cl} $word(${gz.strwords($*) - 2} $*) in $gz.lastw($*)\ kb/s
 xdcc.log $2 \($ref(4-${gz.strwords($*) -2} $*)\) to $1 $word(${gz.strwords($*) - 2} $*) in $gz.lastw($*) kb/s
 @ _xd.h = gz.lastw($*)
 if (_xd.h > xdcc.record) {
  @ xdcc.record = _xd.h
  gxecho New Record: $_xd.h\kb/sec
 }
 purge _xd.h
}

^on ^DCC_SENT "*" {
 ^hook dccchanged
 switch ($1) {
  (SEND) {
#   gxecho Sent DCC SEND request ${gc.peren}\(${cl}$2 $fix.size($3)${gc.peren}\)${cl} to ${gc.nick}$0${cl}
   gxecho Sent DCC SEND request ${gc.peren}\(${cl}$ref(3-${gz.strwords($*) -2} $*) $fix.size($word(${gz.strwords($*) - 2} $*))${gc.peren}\)${cl} to ${gc.nick}$0${cl}
  }
  (*) {
   gxecho Sent DCC \$1\ request to ${gc.nick}$0${cl}
  }
 }
}

^on ^dcc_request "% SEND % % #*" if (!ctcpsnd.dcc_request($*)) {
  gz.playsnd gotdccreq
    gecho $gx $0 is sending you file $2\ \($3 bytes\)
  @ _filename = [$2]
  if (gx.nickfile) {
   if (gz.drivetype($dcc_dldir) == [hpfs]) {
    @ _filename = [$0] ## [-] ## strip($dcc_reject_chars $2)
    gxecho Nick-File Rename: $2 renamed to $_filename
    //dcc rename $0 $2 $_filename
   }{
    gxecho Nick-File Rename: ERROR Rename not possible.  Drivetype: $gz.drivetype($dcc_dldir)
   }
  }
#    if ((_isflagset(ABFIOP $userhost()) && istog(F)) || istog(G)) {
    if (gx.autoget) {
        #playevent A
        gxecho Autogetting file...
        if (fexist($DCC_DLDIR$_filename) != -1) {
            @ new_name = _try_rename($DCC_DLDIR$_filename)
            if (new_name) {
                gxecho Old file renamed to $new_name
            }{
                gxecho Failed to rename old file, overwriting
            }
            //^assign -new_name
        }
        //^dcc get $4
    }{
        #playevent B
        if (fexist($DCC_DLDIR$_filename) != -1) {
            gecho $gx File $_filename \($fsize($DCC_DLDIR$_filename) bytes\) exist in download directory
            gecho $gx Press F11 to close,F12 to receive,Alt-F12 to resume
        }{
            gecho $gx Press F11 to close,F12 to receive
        }
    }
}

^on ^dcc_request "% RESEND % % #*" {
  gz.playsnd gotdccreq
    gecho $gx $0 is resending you file $2\ \($3 bytes\)
    #if ((_isflagset(ABFIOP $userhost()) && istog(F)) || istog(G)) {
    if (gx.autoget) {
        #playevent A
        gecho $gx Autoregetting file...
        //^dcc reget $4
    }{
        #playevent B
        gecho $gx F11 to close and F12 to receive
    }
}

^on ^dcc_request "% CHAT % % #*" {
 gz.playsnd gotdccreq
 @ _mw = gz.maxwins - 1
 gecho $gx DCC \$1\ ${gc.peren}\(${cl}$2 $3${gc.peren}\)${cl} request received from ${gc.nick}$0${cl}
 if (gz.autochat && !winitem($_mw)) {
  /chat $0 -b
 }
 ^assign -_mw
}

^on ^dcc_lost "% % *SEND %* *LOST" {gxecho DCC $2 from $1 \($3\) ${gc.errortopic}$4${cl}}
^on ^dcc_lost "% % *SEND %* *CLOSED" {gxecho DCC $2 from $1 \($3\) ${gc.errortopic}$4${cl}}
^on ^dcc_lost "% % *GET %* *FINISHED*" {gxecho DCC $2 from $1 \($3\) $4}
^on ^dcc_lost "% % *GET %* *CLOSED" {
 gxecho DCC $2 from $1 \($3\) $4
 if (!fsize($3)) {
  gxecho Received 0 length file from $1, deleting file
  @ unlink($3)
 }
}
^on ^dcc_lost "% % *GET %* *LOST" {
 gxecho DCC \$2\ from $1 ${gc.peren}\(${cl}$3${gc.peren}\)${cl} ${gc.errortopic}$4${cl}
 if (!fsize($3)) {
  gxecho Received 0 length file from $1, deleting file
  @ unlink($3)
 }
}

^on ^DCC_LOST "% % *GET %* *COMPLETED*" {
 gz.playsnd dccgetfin
 for (@ _dl.i = 0, _dl.d = dccitem($_dl.i), @ _dl.i++) {
  if ([$0]==word(9 $_dl.d)) {
   if (fsize($3) == word(7 $_dl.d)) {
    gxecho DCC \$2\ from ${gc.nick}$1${cl} ${gc.peren}\(${cl}$3${gc.peren}\)${cl} Completed in $5 kb/sec
    xdcc.log $2 from $1 \($3\) Completed in $5 kb/sec
   }{
    gxecho DCC \$2\ from ${gc.nick}$1${cl} ${gc.peren}\(${cl}$3${gc.peren}\)${cl} ${gc.errortopic}INCOMPLETE${cl}
    gxecho Received $word(6 $_dl.d) of $word(7 $_dl.d) bytes \(Completed in $5 kb/sec\)
    @ _dl.e = 1
   }
  }
 }
 if (!fsize($3)) {
  gxecho Received 0 length file from $1, deleting file
  @ unlink($3)
 }{
  if (gx.autoview && !away && !_dl.e) {
   if (right(4 $3)==[.jpg] || right(4 $3)==[.gif] || right(4 $3)==[.bmp]) {
#   if (match($right(4 $3) .jpg .gif .gmp .tif)) {
    gecho Spawning External Viewer to view $3
    exec -noshell $imageviewer $3
   }
  }
 }
 purge _dl
}


on ^notice "% [gx] *" {
 if (gx.spiffyxdcc) {
  if (([$4]==[packs] || [$4]==[pack]) && (isdigit($3))) {
   @ _tmp6 = [$strip([] $6)]
   @ _tmp8 = [$strip([] $8)]
   @ _tmp11 = [$strip([] $11)]
   xecho -b ${gc.dccbar}  ╔═══════════════════[${gc.gxtitle}GemZ Pack list${gc.dccbar}]═════════════════════╗
   xecho -b ${gc.dccbar}  ║${cl} ${gc.gxnick}From${cl}: ${gc.gxdata}$[12]0${cl}  ${gc.gxitem}Offered Packs${cl}: ${gc.gxdata}$[3]3 ${gc.gxitem}Open slots${cl}: ${gc.gxdata}$[-3]_tmp6 ${gc.dccbar}║${cl}
   xecho -b ${gc.dccbar}  ║${cl}                       ${gc.gxitem}Total Slots${cl}: ${gc.gxdata}$[3]_tmp8 ${gc.gxitem}Queued${cl}: ${gc.gxdata}$[-7]_tmp11 ${gc.dccbar}║${cl}
   xecho -b ${gc.dccbar}  ╠════════════════════════════════════════════════════════╝
   ^assign -_tmp6;^assign -_tmp8;^assign -_tmp11
  }
  else if ([$2]==[Total]) {
   xecho -b ${gc.dccbar}  ╠════════════════════════════════════════════════════════╗
   xecho -b ${gc.dccbar}  ║${cl}      $[53]2- ${gc.dccbar}║${cl}
   xecho -b ${gc.dccbar}  ╚════════════════════════════════════════════════════════╝
  }
  else if ([$2]==[\[Record:] || [$2]==[\[Min:]) {
   xecho -b ${gc.dccbar}  ╠════════════════════════════════════════════════════════╗
   xecho -b ${gc.dccbar}  ║${cl}      $[55]2- ${gc.dccbar}║${cl}
   xecho -b ${gc.dccbar}  ╚════════════════════════════════════════════════════════╝
  }
  else {
   xecho -b ${gc.dccbar}  ║${cl} $2-
  }
 }{
  echo -${gc.notice}$0${cl}- $1-
  @ last.noti = [-$0\- $1- <[$Z]:$userhost()>]
  @ last.note.from = [$0]
 }
}
#############################
#commands available to momos#
#############################
alias xdcc {
 switch ($0) {
  (glist) {gl $*}
  (list) {xdcc.list $1-}
  (save) {xdcc.savepack $1-}
  (load) {xdcc.loadpack $1-}
  (plist) {if (C) {xdcc.plist $lastserver() $C}{gecho $gx You are not in a channel}}
  (pnotice) {if (C) {xdcc.pnotify $lastserver() $C}{gecho $gx You are not in a channel}}
  (offer) {xdcc.offer $1-}
  (doffer) {xdcc.doffer $1-}
  (note) {xdcc.note $1-}
  (file) {xdcc.file $1-}
  (desc) {xdcc.desc $1-}
  (pass) {xdcc.pass $1-}
  (ptime) {xdcc.ptime $1-}
  (savetime) {xdcc.savetime $1-}
  (minspeed) {xdcc.minspeed $1-}
  (qmax) {xdcc.qmax $1-}
  (limit) {xdcc.limit $1-}
  (maxtime) {xdcc.maxtime $1-}
  (qcancel) {xdcc.qcancel $1-}
  (qlist) {xdcc.qlist $1-}
  (psend) {xdcc.psend $1-}
  (autoget) {xdcc.autoget $1-}
  (autosend) {xdcc.autosend $1-}
  (dldir) {xdcc.dldir $1-}
  (uldir) {xdcc.uldir $1-}
  (logfile) {xdcc.logfile $1-}
  (password) {xdcc.password $1-}
  (*) {gecho $gx Unknown or unimplemented xdcc command}
 }
}

alias psend {xdcc psend $*}
alias plist {xdcc plist $*}
alias pnotice {xdcc pnotice $*}
alias qlist {xdcc qlist $*}
alias qcancel {xdcc qcancel $*}
alias doffer {xdcc doffer $*}


gxecho Loading Offers...
xdcc.loadpack

alias xl CTCP $C XDCC LIST $*
alias xlo CTCP $C XDCC OVERVIEW $*

set float off

### XDCC NOLEECH CHECKING
alias validxdcchost {
 @ FUNCTION_RETURN = 1
 for (@ idx = 1, idx <= _xidx, @ idx++) {
  if (match($xhost[$idx][host] $0)) {
   gxecho Disallowed XDCC access \($0\)
   @ FUNCTION_RETURN = 0;//break
  }
 }
}

^set input_prompt ▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░60% (XDCC Subsystem)
^set input_prompt ▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░70% (XDCC Subsystem)
^set input_prompt ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░80% (XDCC Subsystem)

alias cs {if ([$0]) {if ([$1]) {ctcp $0 xdcc send #$1}{ctcp $0 xdcc list}}{gecho $gx Usage: /cs Nick or /cs Nick Pack}}
alias dl gl $*
alias an /xdcc autoget on
alias af /xdcc autoget off
alias s {if ([$0]) {if ([$1]) {msg $0 xdcc send #$1}{msg $0 xdcc list}}{gecho $gx Syntax: /s Nick or /s Nick Pack}}
alias xdl xdcc list

on ^ctcp "% #* XDCC LIST" {
 evalserver $lastserver() {.not $0 Use "/msg $N xdcc list" for listing.}
 xecho -target $1 $gemz $gx Channel Packlist Request: $0 \($userhost()\)
}

^set input_prompt ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░95% (XDCC Offer File)

#################################
# Lame mIRC ^Cx,x colors support#
#################################

# these are aliases that converts mIRC ^Cx,x format to our ^Cxx and back

alias fix.mirc {@ function_return = ansi2c($mirc2cntl($0 $1-))}

^set input_prompt ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░96% (Color Translation)
# mIRC color index to our one
@ _clrtab.0 = [f]
@ _clrtab.1 = [0]
@ _clrtab.2 = [1]
@ _clrtab.3 = [2]
@ _clrtab.4 = [c]
@ _clrtab.5 = [4]
@ _clrtab.6 = [5]
@ _clrtab.7 = [6]
@ _clrtab.8 = [e]
@ _clrtab.9 = [a]
@ _clrtab.10 = [3]
@ _clrtab.11 = [b]
@ _clrtab.12 = [9]
@ _clrtab.13 = [d]
@ _clrtab.14 = [8]
@ _clrtab.15 = [7]

# our color index to mIRC one

@ _backtab.f = [00]
@ _backtab.0 = [01]
@ _backtab.3 = 10
@ _backtab.b = 11
@ _backtab.9 = 12
@ _backtab.d = 13
@ _backtab.8 = 14
@ _backtab.7 = 15
@ _backtab.1 = [02]
@ _backtab.2 = [03]
@ _backtab.c = [04]
@ _backtab.4 = [05]
@ _backtab.5 = [06]
@ _backtab.e = [08]
@ _backtab.a = [09]
@ _backtab.6 = [07]

# $0 == color wich to use as default background color for ^Cnum
# $1... a string to convert

alias mirc2cntl {
# default background color
    @ mc.bc = _backtab[$left(1 $colorvalue($0))]
# do actual conversion using recursive function
    @ function_return = _mirc2cntl($1-)
}

### strips mirc colors
alias mircstrip {
# start
    @ mc.idx = index( $*)
    if (mc.idx == -1) {
        @ function_return = [$*]
    }{
        # take a left part before ^C
        @ mc.p1 = left(${mc.idx++} $*)
        @ mc.n1 = mid($mc.idx 1 $*)
        if (isdigit($mc.n1)) {
            @ mc.idx++
            @ mc.n2 = mid($mc.idx 1 $*)
            if (isdigit($mc.n2)) @ mc.idx++
            # second number after a comma
            if (mid($mc.idx 1 $*)==[,] && isdigit(${mc.n1=mid(${++mc.idx} 1 $*)})) {
                @ mc.idx++
                @ mc.n2 = mid($mc.idx 1 $*)
                if (isdigit($mc.n2)) @ mc.idx++
            }
            @ function_return = [$mc.p1$mircstrip($mid($mc.idx 2048 $*))]
        }{
            # no digit after ^C mean turn on default color in mIRC
            @ function_return = [$mc.p1$mircstripl($mid($mc.idx 2048 $*))]
        }
    }
}

alias mirc2cntl {
# default background color
    @ mc.bc = _backtab[$left(1 $colorvalue($0))]
    @ mc.d = [$colorvalue($0)]
# do actual conversion using recursive function
    @ function_return = _mirc2cntl($1-)
}

alias _mirc2cntl {
# start
    @ mc.idx = index( $*)
    if (mc.idx == -1) {
        @ function_return = [$*]
    }{
        # take a left part before ^C
        @ mc.p1 = left(${mc.idx++} $*)
        @ mc.b = mc.bc
        @ mc.n1 = mid($mc.idx 1 $*)
        if (isdigit($mc.n1)) {
            @ mc.idx++
            @ mc.n2 = mid($mc.idx 1 $*)
            if (isdigit($mc.n2)) @ mc.idx++
            else @ mc.n2 = []
            @ mc.f = mc.n1 ## mc.n2
            # second number after a comma
            if (mid($mc.idx 1 $*)==[,] && isdigit(${mc.n1=mid(${++mc.idx} 1 $*)})) {
                @ mc.idx++
                @ mc.n2 = mid($mc.idx 1 $*)
                if (isdigit($mc.n2)) @ mc.idx++
                else @ mc.n2 = []
                @ mc.b = mc.n1 ## mc.n2
            }
            @ function_return = [$mc.p1\$_clrtab[${mc.b & 15}]$_clrtab[${mc.f & 15}]$_mirc2cntl($mid($mc.idx 2048 $*))]
        }{
            # no digit after ^C mean turn on default color in mIRC
            @ function_return = [$mc.p1$mc.d$_mirc2cntl($mid($mc.idx 2048 $*))]
        }
    }
}

alias cntl2mirc {
# default background color
    @ mc.bc = left(1 $0)
# do actual conversion using recursive function
    @ function_return = _cntl2mirc($1-)
}

alias _cntl2mirc {
# start
    @ mc.idx = index( $*)
    if (mc.idx == -1) {
        @ function_return = [$*]
    }{
        # take a left part before ^C
        @ mc.p1 = left(${mc.idx++} $*)
        @ mc.b = mc.bc
        @ mc.n1 = mid($mc.idx 1 $*)
        if (isxdigit($mc.n1)) {
            @ mc.f = mc.n1
            @ mc.idx++
            # second hex digit
            @ mc.n2 = mid($mc.idx 1 $*)
            if (isxdigit($mc.n2)) {
                @ mc.b = mc.f
                @ mc.idx++
                @ mc.f = mc.n2
            }{
                @ mc.b = mc.bc
            }
            if (mid($mc.idx 1 $*)==[]) {
                @ function_return = [$mc.p1$_cntl2mirc($mid($mc.idx 2048 $*))]
            }{
                @ mc.ln = [$_backtab[$mc.f]\,$_backtab[$mc.b]]
                if (mc.ln!=mc.l) {
                    @mc.l = mc.ln
                    @ function_return = [$mc.p1$mc.l$_cntl2mirc($mid($mc.idx 2048 $*))]
                }{
                    @ function_return = [$mc.p1$_cntl2mirc($mid($mc.idx 2048 $*))]
                }
            }
        }{
            # no hex digit after ^C mean we just eat an ^C
            @ function_return = [$mc.p1$_mirc2cntl($mid($mc.idx 2048 $*))]
        }
    }
}

#### END MIRC CRAP ####

###################################
#### Ansi to ^C Conversion support#
###################################

###Ansi number to ^C number table
@ _ansi[0] = [0]
@ _ansi[1] = [4]
@ _ansi[2] = [2]
@ _ansi[3] = [6]
@ _ansi[4] = [1]
@ _ansi[5] = [5]
@ _ansi[6] = [3]
@ _ansi[7] = [7]
#these used if highlight = 1
@ _hansi[0] = [8]
@ _hansi[1] = [C]
@ _hansi[2] = [A]
@ _hansi[3] = [E]
@ _hansi[4] = [9]
@ _hansi[5] = [D]
@ _hansi[6] = [B]
@ _hansi[7] = [F]


alias _rconvert {
 switch ($0) {
   (0) {@ function_return = [0];@ highlight = [0]}
   (4) {@ function_return = [1];@ highlight = [0]}
   (2) {@ function_return = [2];@ highlight = [0]}
   (6) {@ function_return = [3];@ highlight = [0]}
   (1) {@ function_return = [4];@ highlight = [0]}
   (5) {@ function_return = [5];@ highlight = [0]}
   (3) {@ function_return = [6];@ highlight = [0]}
   (7) {@ function_return = [7];@ highlight = [0]}
   (8) {@ function_return = [0];@ highlight = [1]}
   (C) {@ function_return = [1];@ highlight = [1]}
   (A) {@ function_return = [2];@ highlight = [1]}
   (E) {@ function_return = [3];@ highlight = [1]}
   (9) {@ function_return = [4];@ highlight = [1]}
   (D) {@ function_return = [5];@ highlight = [1]}
   (B) {@ function_return = [6];@ highlight = [1]}
   (F) {@ function_return = [7];@ highlight = [1]}
 }
}

alias split {
 fec ($1-) __s.1 {
  if (__s.1==[$0]) {@ __s.2 #= [ ]}
  else if (__s.1==[ ]) {}
  else {@ __s.2 #= __s.1}
 }
 @ function_return = __s.2
 purge __s
}

alias ansireset {
 @ foreground = _rconvert($right(1 $color_normal))
 @ background = _rconvert($left(1 $color_normal))
}

alias convertcode {
 if ([$0]==[\[0m]) {
  @ function_return = [$color_normal]
  ansireset
 }{
  @ _code = strip(m\[ $*)
  if (_code==[0]) {@ highlight = 0}
  else {
   fe ($split(; $_code)) _code.2 {
    if (left(1 $_code.2)==3) {@ foreground = right(1 $_code.2)}
    else if (left(1 $_code.2)==4) {@ background = right(1 $_code.2)}
    else if (_code.2==1) {@ highlight = 1}
    else if (_code.2==0) {@ highlight = 0}
   }
  }
  @ function_return = [$_convert.b($background)$_convert.f($foreground)]
  purge _code
 }
}

alias _convert.f {if (highlight) {@ function_return = [$_hansi[$0]]}{@ function_return = [$_ansi[$0]]}}
alias _convert.b {@ function_return = _ansi[$0]}

alias ansi2c {
 if (gz.ansi) {
# we reset background/foreground.  Ansi codes are weird beasts.
# and this is highly specialized for IRC clients that use ansi
  ansireset
  if (index( $*) >= 0) {
   @ _left = left($index( $*) $*)
   @ _right = mid(${index( $*)+1} $@* $*)
   @ _tmp = index(m $_right)
   if (_tmp == -1) {
    # screw it, bad escape sequence
    @function_return = [$*]
   }{
   @ _tmp++
    @ _mid = mid(0 $_tmp $_right)
    @ _rest = mid($_tmp $@_right $_right)
    @ function_return = _left ## convertcode($_mid) ## ansi2c($_rest)
   }
  }{
   @ function_return = [$*]
  }
 }{
  @ function_return = [$*]
 }
}


### End Ansi Conversion ###

^set input_prompt ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░97% (Final Setup)
#final Cleanup #
#load gemz save file
eval gecho Loading GemZ/2 savefile: $gzsavefile
if (!gemzloaded) {
 _statgl
 update_uptime
 ^eval ^set status_user2 [M:0/P:0]
 @ msglog_cnt = [0]
 @ publog_cnt = [0]
}{
 clearignorelist
}


EVAL load $gzsavefile
if (fexist($dcc_dldir) != 1) {
 gecho Invalid or No Download Directory specified.
 gecho Defaulting to $exedir/download
 if (fexist($exedir/download) !=1) {@ mkdir($exedir/download)}
 eval ^set DCC_DLDIR $exedir/download
}
if (!gemzloaded) {/codepage $default_codepage}
settitlebar
if (gz.loadextras) {load gzextras.irc}
eval @ fig.fontfile = [$def.figfont]
eval @ figfont = [$fig.fontdir/$def.figfont\.flf]

update_vars
alias -update_vars

eval load gemzmenu.irc
eval gecho Loading GemZ/2 ColorFile: $exedir/colors.gmz
eval load $exedir/colors.gmz
#EVAL load gemzhelp.irc
alias ghelp {
 gecho Please use /help.
 gecho Old /ghelp IRC file has been replaced with OS/2 help file
}

eval if ([$fexist($gz.logdir)]!=[1]) {
 @ mkdir($gz.logdir)
}
eval if (!gemzloaded) {
 ^set SOUND_PATH $SOUND_PATH$DOWNLOADDIR
 gecho Loading OpenChat/2 Help file, use /help for OpenChat/2 help
 gecho use /ghelp for GemZ help
 /help -file $exedir/script2/gemzhelp.hlp
 @ _ghelp = 1
}

eval if (fexist($exedir/script2/gemzhelp.new)==1) {
 gecho New help file detected... upgrading...
 eval //help -file $exedir/OpenChat.hlp
 eval @ unlink($exedir/script2/gemzhelp.hlp)
 eval @ rename($exedir/script2/gemzhelp.new $exedir/script2/gemzhelp.hlp)
 eval //help -file $exedir/script2/gemzhelp.hlp
 gecho upgrade finished
 #^timer 2 //help whatsnew
}

eval set_reply
alias setinput {
 if (gz.inputchan) {
  ^set input_prompt \${ T ? [<$T> ] : [<none> ]}
 }{
  ^set input_prompt \${ T ? [<$N> ] : [<$N> ]}
 }
}

^set input_prompt ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒100%
gecho Finished!

eval setinput

^on #^timer 70 * netclean
^on #^timer 10 * {
 gz.checkfixnick
 gz.testbans
 if (gz.autosave) {
  if ([$_astime]==[]) {@ _astime = 0}{@ _astime++}
  if ((_astime >= gz.astime) && (_astime != 0) && (gz.astime != 0)) {
   @ _astime = 0
   gsave quiet
  }
 }
# all purpose minute timer for GemZ
 for (@ cnt = 0, _blah = dccitem($cnt), @ cnt++) {
  if (gz.dcctimeout > 0 && [$word(0 $_blah)]==[chat] && ([$word(2 $_blah)]==[waiting] || [$word(2 $_blah)]==[offered])) {
   @ _time = time() - word(3 $_blah)
   @ _dtime = gz.dcctimeout * 60
   if (_time > _dtime) {
    gecho $gx DCC CHAT Timeout after $gz.dcctimeout minutes
    /dcc close chat $word(1 $_blah)
    ^nochat $word(1 $_blah)
   }
   ^assign -_time
  }
 }
 if (hourlytime==[ON] && (rmatch($0 %:00*) || (gz.halfhour && rmatch($0 %:30*))) ) {
  for (@ idx = 0, (win = winitem($idx)), @ idx++) {
   if (win) {xecho -window $word(0 $win) $gemz The Time is now ${gc.time}$gz.timedate()${cl}}
  }
 }
 ^assign -_blah
 ^assign -cnt
}


alias useclock {
 if ([$0]==[Toggle]) {
  @ gz.useclock = _tog($gz.useclock)
 }
 setstatusbar
}

alias setstatusbar {
 @ gt.statbar = [normal]
 if (gz.useclock) {
  ^set status_format %B%T%F %H%@%N%*%# %A %Q%C%+ %Z %>%4%0
 }{
  ^set status_format %B<gz $gemz.ver>%F %H%@%N%*%# %A %Q%C%+ %Z %>%4%0
 }
}

setstatusbar

if (!gender) {
 @ tmp = [$"Size your default window position \[press enter\]"]
 fontdialog
 input "Are you [M]ale or [F]emale? " if ([$0]) {
  if ([$0]==[F]) {@ gender = [her];@ gender.2 = [she]}
  {@ gender = [his];@ gender.2 = [he]}
  gecho Saving information...
  eval gsave
 }
 ^assign -tmp
}

eval if ([$loadacts]==[YES]) {eval loadplug $actionsfile}
#if load was a reload, it's no longer now
^assign -reloading
on ^disconnect * {
 if ([$re.connect]==[ON]) {
  if (!dt.timer) {
   gecho Disconnected, autocycle to first server in 5 seconds...
   ^timer 5 if (1) {
    if ((serverwindows($lastserver())  != []) && (!isconnected($lastserver()))) {
     /server +
    }
    @ dt.timer = 0
   }
   @ dt.timer = 1
  }
 }
}

### ignore menu and sample /ig code
### each ignore item have a submenu with all the ignore types: MSGS PUBLIC
### WALLS WALLOPS INVITES NOTICES NOTES CTCPS CRAP ACTIONS
###
### Note that ALL and NONE are not included, coz ALL mean ignore all of
### the above types, and NONE mean remove ignore item
###

### $0 == number in ignore list $1 == nick|mask  $2 == ignore type
alias _ign.toggle {
    if (!isignored($2 $1 $1)) {
        /__ignore $1 $2
        @menucontrol(check 1)
    }
    else if (ref(4- $ignoreitem($0)) == [$2]) {
        # its a last ignored type, ignore will be removed
        # note that ^ is not used, so client displays
        # blah removed from ignore list message
        @__ignoremenucommand++
        //ignore $1 -$2
        @__ignoremenucommand--
        //^timer 0 _recreate_ign_menu
    }
    else {
        /__ignore $1 -$2
        @menucontrol(check 0)
    }
}

### following code is used to prevent on ^ignore_list from recreating
### ignore list when we adding/removing ignores from menu itself...

alias clearignorelist while (ignoreitem(0) != []) {/^__ignore -0}

@__ignmenucommand = 0
alias __ignore {
    @__ignoremenucommand++
    //ignore $*
    @__ignoremenucommand--
}

alias _recreate_ign_menu {
    menu -ign
    menu ign
    for (@ii=0, (tmp=ignoreitem($ii)) != [], @ii++) {
        if (word(2 $tmp) == -1) {
            submenu ign ign$ii "# $tolower($word(0 $tmp))"
        }{
            submenu ign ign$ii "$word(2 $tmp) $tolower($word(0 $tmp))"
        }
        fe (MSGS PUBLIC INVITES NOTICES CTCPS ACTIONS CRAP WALLS WALLOPS NOTES) ign.type {
            if (match($ign.type $ref(4- $tmp)) || ref(4- $tmp) == [ALL]) @ ign.c = [-c]
            else @ ign.c = []
            //menuitem ign$ii -n $ign.c "$ign.type" _ign.toggle $ii $word(0 $tmp) $ign.type
        }
        menuitem ign$ii separator
        menuitem ign$ii "~Remove" //ignore -$ii
    }
    if (!ii) {menuitem ign "Ignore List is Empty" {}}
    menu ign -reset
}

on ^ignore_list * if (!__ignoremenucommand) {
    _recreate_ign_menu
}

_recreate_ign_menu

alias ig {
 if ([$0]) {
  switch ($1) {
   (-t) {_ig $*}
   (-p) {_ig $0 $2-}
   (*) {if (gz.igtimeout) {_ig $0 -t ${gz.igtimeout * 60} $1-}{_ig $*}}
  }
 }{_ig}
}


alias _ig {
    if (index(*?@ $0) >= 0) //ig $*
    else if (![$0]) //ig
    else {
        @_found = 0
        fe ($mychannels()) _ch {
            if (onchannel($0 $_ch) && nickdata($_ch $0) != [<UNKNOWN>]) {
                @_found = 1
                @_uh = nickdata($_ch $0)
                //break
            }
        }
        if (_found) //ig *$mask.userhost($_uh) $1-
        else //userhost $0 -cmd _ig.uhcmd $0 $$* $1-
    }
}

alias _ig.uhcmd {
    if ([$4] == [<UNKNOWN>]) {
        echo $SHOW_NUMERICS_STR\Nick $1\ is not online
    }{
        //ig *$mask.userhost($4@$5) $6-
    }
}

alias snap {
 if (![$0]) {
  /xecho $SHOW_NUMERICS_STR\Usage: /snap <filename>
 }{
  //lastlog -snap $0
 }
}

### end of ignore menu and simple /ig

######Load Mikh's Tabkey Code#######
on ^window "*compl.add*" #
load complete
load tabkey
load load.cpl
load play.cpl
load dcc.cpl
load nick.cpl
load kick.cpl
load whois.cpl
load file.cpl
on ^window -"*compl.add*"
#####################################

alias _check_groups_present {
 @have_server_groups = 0
 for (@ii=0, servername($ii), @ii++) {
  if (servergroup($ii) != [none]) {
   @ have_server_groups = 1
   //break
  }
 }
 if (!have_server_groups) {/help Server Groups}
 //^assign -have_server_groups
}

_check_groups_present
alias dcc.sendfile_with_timeout {ctcpsnd.sendfile_with_timeout $*}

alias _gz.checkver {if (V < 19970822) {/help upgrade}}
_gz.checkver
 newsettings = 0
^set preparse_aliases 0
^set dcc_autoget off

alias -_gz.checkver
alias -_check_groups_present

#Things to remove for previous versions
^on connect -"*" #
^on ^public -"% % *http:*"
^on ^public -"% % *ftp:*"
^alias -dialogresend
^alias -dialogsend
^assign -gz.opernotify

on ^hook "gzreload" {gz.reload}
eval if (gemzloaded) {^hook gzreload}

@ gemzloaded = [1]
#All scripts for gemz should run this at the end.
gz.setvers
csq.qtimer

#EOF