%%

%% This is file `wccfl2.bst',

%% generated with the docstrip utility.

%%

%% The original source files were:

%%

%% merlin.mbs  (with options: `,ay,nat,seq-lab,vonx,nm-revv1,keyxyr,dt-beg,note-yr,pgsep-s,add-pub,url,url-nl,pp,xedn,and-xcom')

%% ----------------------------------------

%% *** WCCFL BibTex style -- compatible with Natbib ***

%% 

%% Copyright 1994-1999 Patrick W Daly

 % ===============================================================

 % IMPORTANT NOTICE:

 % This bibliographic style (bst) file has been generated from one or

 % more master bibliographic style (mbs) files, listed above.

 %

 % This generated file can be redistributed and/or modified under the terms

 % of the LaTeX Project Public License Distributed from CTAN

 % archives in directory macros/latex/base/lppl.txt; either

 % version 1 of the License, or any later version.

 % ===============================================================

 % Name and version information of the main mbs file:

 % \ProvidesFile{merlin.mbs}[1999/05/28 3.89 (PWD)]

 %   For use with BibTeX version 0.99a or later

 %-------------------------------------------------------------------

 % This bibliography style file is intended for texts in ENGLISH

 % This is an author-year citation style bibliography. As such, it is

 % non-standard LaTeX, and requires a special package file to function properly.

 % Such a package is    natbib.sty   by Patrick W. Daly

 % The form of the \bibitem entries is

 %   \bibitem[Jones et al.(1990)]{key}...

 %   \bibitem[Jones et al.(1990)Jones, Baker, and Smith]{key}...

 % The essential feature is that the label (the part in brackets) consists

 % of the author names, as they should appear in the citation, with the year

 % in parentheses following. There must be no space before the opening

 % parenthesis!

 % With natbib v5.3, a full list of authors may also follow the year.

 % In natbib.sty, it is possible to define the type of enclosures that is

 % really wanted (brackets or parentheses), but in either case, there must

 % be parentheses in the label.

 % The \cite command functions as follows:

 %   \citet{key} ==>>                Jones et al. (1990)

 %   \citet*{key} ==>>               Jones, Baker, and Smith (1990)

 %   \citep{key} ==>>                (Jones et al., 1990)

 %   \citep*{key} ==>>               (Jones, Baker, and Smith, 1990)

 %   \citep[chap. 2]{key} ==>>       (Jones et al., 1990, chap. 2)

 %   \citep[e.g.][]{key} ==>>        (e.g. Jones et al., 1990)

 %   \citep[e.g.][p. 32]{key} ==>>   (e.g. Jones et al., p. 32)

 %   \citeauthor{key} ==>>           Jones et al.

 %   \citeauthor*{key} ==>>          Jones, Baker, and Smith

 %   \citeyear{key} ==>>             1990

 %---------------------------------------------------------------------



ENTRY

  { address

    author

    booktitle

    chapter

    edition

    editor

    howpublished

    institution

    journal

    key

    month

    note

    number

    organization

    pages

    publisher

    school

    series

    title

    type

    url

    volume

    year

  }

  {}

  { label extra.label sort.label short.list }



INTEGERS { output.state before.all mid.sentence after.sentence after.block }



FUNCTION {init.state.consts}

{ #0 'before.all :=

  #1 'mid.sentence :=

  #2 'after.sentence :=

  #3 'after.block :=

}



STRINGS { s t }



FUNCTION {output.nonnull}

{ 's :=

  output.state mid.sentence =

    { ", " * write$ }

    { output.state after.block =

        { add.period$ write$

          newline$

          "\newblock " write$

        }

        { output.state before.all =

            'write$

            { add.period$ " " * write$ }

          if$

        }

      if$

      mid.sentence 'output.state :=

    }

  if$

  s

}



FUNCTION {output}

{ duplicate$ empty$

    'pop$

    'output.nonnull

  if$

}



FUNCTION {output.check}

{ 't :=

  duplicate$ empty$

    { pop$ "empty " t * " in " * cite$ * warning$ }

    'output.nonnull

  if$

}



FUNCTION {fin.entry}

{ add.period$

  write$

  newline$

}



FUNCTION {new.block}

{ output.state before.all =

    'skip$

    { after.block 'output.state := }

  if$

}



FUNCTION {new.sentence}

{ output.state after.block =

    'skip$

    { output.state before.all =

        'skip$

        { after.sentence 'output.state := }

      if$

    }

  if$

}



FUNCTION {add.blank}

{  " " * before.all 'output.state :=

}



FUNCTION {date.block}

{

  new.block

}



FUNCTION {not}

{   { #0 }

    { #1 }

  if$

}



FUNCTION {and}

{   'skip$

    { pop$ #0 }

  if$

}



FUNCTION {or}

{   { pop$ #1 }

    'skip$

  if$

}



FUNCTION {new.block.checkb}

{ empty$

  swap$ empty$

  and

    'skip$

    'new.block

  if$

}



FUNCTION {field.or.null}

{ duplicate$ empty$

    { pop$ "" }

    'skip$

  if$

}



FUNCTION {emphasize}

{ duplicate$ empty$

    { pop$ "" }

    { "{\em " swap$ * "\/}" * }

  if$

}





FUNCTION {capitalize}

{ "u" change.case$ "t" change.case$ }



FUNCTION {space.word}

{ " " swap$ * " " * }



 % Here are the language-specific definitions for explicit words.

 % Each function has a name bbl.xxx where xxx is the English word.

 % The language selected here is ENGLISH

FUNCTION {bbl.and}

{ "and"}



FUNCTION {bbl.etal}

{ "et~al." }



FUNCTION {bbl.editors}

{ "editors" }



FUNCTION {bbl.editor}

{ "editor" }



FUNCTION {bbl.edby}

{ "edited by" }



FUNCTION {bbl.edition}

{ "edition" }



FUNCTION {bbl.volume}

{ "volume" }



FUNCTION {bbl.of}

{ "of" }



FUNCTION {bbl.number}

{ "number" }



FUNCTION {bbl.nr}

{ "no." }



FUNCTION {bbl.in}

{ "in" }



FUNCTION {bbl.pages}

{ "pp." }



FUNCTION {bbl.page}

{ "p." }



FUNCTION {bbl.chapter}

{ "chapter" }



FUNCTION {bbl.techrep}

{ "Technical Report" }



FUNCTION {bbl.mthesis}

{ "Master's thesis" }



FUNCTION {bbl.phdthesis}

{ "Ph.D. thesis" }



MACRO {jan} {"January"}



MACRO {feb} {"February"}



MACRO {mar} {"March"}



MACRO {apr} {"April"}



MACRO {may} {"May"}



MACRO {jun} {"June"}



MACRO {jul} {"July"}



MACRO {aug} {"August"}



MACRO {sep} {"September"}



MACRO {oct} {"October"}



MACRO {nov} {"November"}



MACRO {dec} {"December"}



MACRO {acmcs} {"ACM Computing Surveys"}



MACRO {acta} {"Acta Informatica"}



MACRO {cacm} {"Communications of the ACM"}



MACRO {ibmjrd} {"IBM Journal of Research and Development"}



MACRO {ibmsj} {"IBM Systems Journal"}



MACRO {ieeese} {"IEEE Transactions on Software Engineering"}



MACRO {ieeetc} {"IEEE Transactions on Computers"}



MACRO {ieeetcad}

 {"IEEE Transactions on Computer-Aided Design of Integrated Circuits"}



MACRO {ipl} {"Information Processing Letters"}



MACRO {jacm} {"Journal of the ACM"}



MACRO {jcss} {"Journal of Computer and System Sciences"}



MACRO {scp} {"Science of Computer Programming"}



MACRO {sicomp} {"SIAM Journal on Computing"}



MACRO {tocs} {"ACM Transactions on Computer Systems"}



MACRO {tods} {"ACM Transactions on Database Systems"}



MACRO {tog} {"ACM Transactions on Graphics"}



MACRO {toms} {"ACM Transactions on Mathematical Software"}



MACRO {toois} {"ACM Transactions on Office Information Systems"}



MACRO {toplas} {"ACM Transactions on Programming Languages and Systems"}



MACRO {tcs} {"Theoretical Computer Science"}



FUNCTION {write.url}

{ url empty$

    { skip$ }

    { "\newline\urlprefix\url{" url * "}" * write$ newline$ }

  if$

}





INTEGERS { nameptr namesleft numnames }



FUNCTION {format.names}

{ 's :=

  "" 't :=

  #1 'nameptr :=

  s num.names$ 'numnames :=

  numnames 'namesleft :=

    { namesleft #0 > }

    { nameptr #1 >

        { s nameptr "{ff~}{vv~}{ll}{, jj}" format.name$  }

        { s nameptr "{vv~}{ll}{, ff}{, jj}" format.name$  }

      if$

    't :=

      nameptr #1 >

        {

          namesleft #1 >

            { ", " * t * }

            {

              s nameptr "{ll}" format.name$ duplicate$ "others" =

                { 't := }

                { pop$ }

              if$

              t "others" =

                {

                  " " * bbl.etal *

                }

                { bbl.and

                  space.word * t *

                }

              if$

            }

          if$

        }

        't

      if$

      nameptr #1 + 'nameptr :=

      namesleft #1 - 'namesleft :=

    }

  while$

}



FUNCTION {format.names.ed}

{ 's :=

  "" 't :=

  #1 'nameptr :=

  s num.names$ 'numnames :=

  numnames 'namesleft :=

    { namesleft #0 > }

    { s nameptr

      "{ff~}{vv~}{ll}{, jj}"

      format.name$

      't :=

      nameptr #1 >

        {

          namesleft #1 >

            { ", " * t * }

            {

              s nameptr "{ll}" format.name$ duplicate$ "others" =

                { 't := }

                { pop$ }

              if$

              t "others" =

                {



                  " " * bbl.etal *

                }

                { bbl.and

                  space.word * t *

                }

              if$

            }

          if$

        }

        't

      if$

      nameptr #1 + 'nameptr :=

      namesleft #1 - 'namesleft :=

    }

  while$

}



FUNCTION {format.key}

{ empty$

    { key field.or.null }

    { "" }

  if$

}



FUNCTION {format.authors}

{ author empty$

    { "" }

    { author format.names }

  if$

}



FUNCTION {format.editors}

{ editor empty$

    { "" }

    { editor format.names

      ", " *

      editor num.names$ #1 >

        'bbl.editors

        'bbl.editor

      if$

      *

    }

  if$

}



FUNCTION {format.in.editors}

{ editor empty$

    { "" }

    { editor format.names.ed

      editor num.names$ #1 >

        { ", " * bbl.editors * }

        { ", " * bbl.editor * }

      if$

    }

  if$

}



FUNCTION {format.note}

{

 note empty$

    { "" }

    { note #1 #1 substring$

      duplicate$ "{" =

        'skip$

        { output.state mid.sentence =

          { "l" }

          { "u" }

        if$

        change.case$

        }

      if$

      note #2 global.max$ substring$ *

    }

  if$

}



FUNCTION {format.title}

{ title empty$

    { "" }

    { title "t" change.case$

    }

  if$

}



FUNCTION {format.full.names}

{'s :=

 "" 't :=

  #1 'nameptr :=

  s num.names$ 'numnames :=

  numnames 'namesleft :=

    { namesleft #0 > }

    { s nameptr

      "{vv~}{ll}" format.name$

      't :=

      nameptr #1 >

        {

          namesleft #1 >

            { ", " * t * }

            {

              s nameptr "{ll}" format.name$ duplicate$ "others" =

                { 't := }

                { pop$ }

              if$

              t "others" =

                {

                  " " * bbl.etal *

                }

                {

                  bbl.and

                  space.word * t *

                }

              if$

            }

          if$

        }

        't

      if$

      nameptr #1 + 'nameptr :=

      namesleft #1 - 'namesleft :=

    }

  while$

}



FUNCTION {author.editor.key.full}

{ author empty$

    { editor empty$

        { key empty$

            { cite$ #1 #3 substring$ }

            'key

          if$

        }

        { editor format.full.names }

      if$

    }

    { author format.full.names }

  if$

}



FUNCTION {author.key.full}

{ author empty$

    { key empty$

         { cite$ #1 #3 substring$ }

          'key

      if$

    }

    { author format.full.names }

  if$

}



FUNCTION {editor.key.full}

{ editor empty$

    { key empty$

         { cite$ #1 #3 substring$ }

          'key

      if$

    }

    { editor format.full.names }

  if$

}



FUNCTION {make.full.names}

{ type$ "book" =

  type$ "inbook" =

  or

    'author.editor.key.full

    { type$ "proceedings" =

        'editor.key.full

        'author.key.full

      if$

    }

  if$

}



FUNCTION {output.bibitem}

{ newline$

  "\bibitem[{" write$

  label write$

  ")" make.full.names duplicate$ short.list =

     { pop$ }

     { * }

   if$

  "}]{" * write$

  cite$ write$

  "}" write$

  newline$

  ""

  before.all 'output.state :=

}



FUNCTION {if.digit}

{ duplicate$ "0" =

  swap$ duplicate$ "1" =

  swap$ duplicate$ "2" =

  swap$ duplicate$ "3" =

  swap$ duplicate$ "4" =

  swap$ duplicate$ "5" =

  swap$ duplicate$ "6" =

  swap$ duplicate$ "7" =

  swap$ duplicate$ "8" =

  swap$ "9" = or or or or or or or or or

}

FUNCTION {n.separate}

{ 't :=

  ""

  #0 'numnames :=

  { t empty$ not }

  { t #-1 #1 substring$ if.digit

      { numnames #1 + 'numnames := }

      { #0 'numnames := }

    if$

    t #-1 #1 substring$ swap$ *

    t #-2 global.max$ substring$ 't :=

    numnames #5 =

      { duplicate$ #1 #2 substring$ swap$

        #3 global.max$ substring$

        "\," swap$ * *

      }

      'skip$

    if$

  }

  while$

}

FUNCTION {n.dashify}

{

  n.separate

  't :=

  ""

    { t empty$ not }

    { t #1 #1 substring$ "-" =

        { t #1 #2 substring$ "--" = not

            { "--" *

              t #2 global.max$ substring$ 't :=

            }

            {   { t #1 #1 substring$ "-" = }

                { "-" *

                  t #2 global.max$ substring$ 't :=

                }

              while$

            }

          if$

        }

        { t #1 #1 substring$ *

          t #2 global.max$ substring$ 't :=

        }

      if$

    }

  while$

}



FUNCTION {word.in}

{ bbl.in capitalize

  " " * }



FUNCTION {format.date}

{ year duplicate$ empty$

    { "empty year in " cite$ * "; set to ????" * warning$

       pop$ "????" }

    'skip$

  if$

  extra.label *

}



FUNCTION {format.btitle}

{ title emphasize

}



FUNCTION {tie.or.space.connect}

{ duplicate$ text.length$ #3 <

    { "~" }

    { " " }

  if$

  swap$ * *

}



FUNCTION {either.or.check}

{ empty$

    'pop$

    { "can't use both " swap$ * " fields in " * cite$ * warning$ }

  if$

}



FUNCTION {format.bvolume}

{ volume empty$

    { "" }

    { bbl.volume volume tie.or.space.connect

      series empty$

        'skip$

        { bbl.of space.word * series emphasize * }

      if$

      "volume and number" number either.or.check

    }

  if$

}



FUNCTION {format.number.series}

{ volume empty$

    { number empty$

        { series field.or.null }

        { output.state mid.sentence =

            { bbl.number }

            { bbl.number capitalize }

          if$

          number tie.or.space.connect

          series empty$

            { "there's a number but no series in " cite$ * warning$ }

            { bbl.in space.word * series * }

          if$

        }

      if$

    }

    { "" }

  if$

}





FUNCTION {format.edition}

{ edition empty$

    { "" }

    { output.state mid.sentence =

        { edition "l" change.case$ " " * bbl.edition * }

        { edition "t" change.case$ " " * bbl.edition * }

      if$

    }

  if$

}



INTEGERS { multiresult }



FUNCTION {multi.page.check}

{ 't :=

  #0 'multiresult :=

    { multiresult not

      t empty$ not

      and

    }

    { t #1 #1 substring$

      duplicate$ "-" =

      swap$ duplicate$ "," =

      swap$ "+" =

      or or

        { #1 'multiresult := }

        { t #2 global.max$ substring$ 't := }

      if$

    }

  while$

  multiresult

}



FUNCTION {format.pages}

{ pages empty$

    { "" }

    { pages multi.page.check

        { bbl.pages pages n.dashify tie.or.space.connect }

        { bbl.page pages tie.or.space.connect }

      if$

    }

  if$

}



FUNCTION {format.journal.pages}

{ pages empty$

    'skip$

    { duplicate$ empty$

        { pop$ format.pages }

        {

          ":" *

          pages n.dashify *

        }

      if$

    }

  if$

}



FUNCTION {format.vol.num.pages}

{ volume field.or.null

  number empty$

    'skip$

    {

      "(" number * ")" * *

      volume empty$

        { "there's a number but no volume in " cite$ * warning$ }

        'skip$

      if$

    }

  if$

  format.journal.pages

}



FUNCTION {format.chapter.pages}

{ chapter empty$

    'format.pages

    { type empty$

        { bbl.chapter }

        { type "l" change.case$ }

      if$

      chapter tie.or.space.connect

      pages empty$

        'skip$

        { ", " * format.pages * }

      if$

    }

  if$

}



FUNCTION {format.in.ed.booktitle}

{ booktitle empty$

    { "" }

    { editor empty$

        { word.in booktitle emphasize * }

        { word.in format.in.editors * ", " *

          booktitle emphasize * }

      if$

    }

  if$

}



FUNCTION {format.thesis.type}

{ type empty$

    'skip$

    { pop$

      type "t" change.case$

    }

  if$

}



FUNCTION {format.tr.number}

{ type empty$

    { bbl.techrep }

    'type

  if$

  number empty$

    { "t" change.case$ }

    { number tie.or.space.connect }

  if$

}



FUNCTION {format.article.crossref}

{

  word.in

  " \cite{" * crossref * "}" *

}



FUNCTION {format.book.crossref}

{ volume empty$

    { "empty volume in " cite$ * "'s crossref of " * crossref * warning$

      word.in

    }

    { bbl.volume capitalize

      volume tie.or.space.connect

      bbl.of space.word *

    }

  if$

  " \cite{" * crossref * "}" *

}



FUNCTION {format.incoll.inproc.crossref}

{

  word.in

  " \cite{" * crossref * "}" *

}



FUNCTION {format.org.or.pub}

{ 't :=

  ""

  address empty$ t empty$ and

    'skip$

    {

      address empty$

        'skip$

        { address * }

      if$

      t empty$

        'skip$

        { address empty$

            'skip$

            { ": " * }

          if$

          t *

        }

      if$

    }

  if$

}



FUNCTION {format.publisher.address}

{ publisher empty$

    { "empty publisher in " cite$ * warning$

      ""

    }

    { publisher }

  if$

  format.org.or.pub

}



FUNCTION {format.organization.address}

{ organization empty$

    { "" }

    { organization }

  if$

  format.org.or.pub

}



FUNCTION {article}

{ output.bibitem

  format.authors "author" output.check

  author format.key output

  format.date "year" output.check

  date.block

  format.title "title" output.check

  new.block

  crossref missing$

    { journal

      emphasize

      "journal" output.check

      format.vol.num.pages output

    }

    { format.article.crossref output.nonnull

      format.pages output

    }

  if$

  new.block

  format.note output

  fin.entry

  write.url

}



FUNCTION {book}

{ output.bibitem

  author empty$

    { format.editors "author and editor" output.check

      editor format.key output

    }

    { format.authors output.nonnull

      crossref missing$

        { "author and editor" editor either.or.check }

        'skip$

      if$

    }

  if$

  format.date "year" output.check

  date.block

  format.btitle "title" output.check

  crossref missing$

    { format.bvolume output

      new.block

      format.number.series output

      new.sentence

      format.publisher.address output

    }

    {

      new.block

      format.book.crossref output.nonnull

    }

  if$

  format.edition output

  new.block

  format.note output

  fin.entry

  write.url

}



FUNCTION {booklet}

{ output.bibitem

  format.authors output

  author format.key output

  format.date "year" output.check

  date.block

  format.title "title" output.check

  new.block

  howpublished output

  address output

  new.block

  format.note output

  fin.entry

  write.url

}



FUNCTION {inbook}

{ output.bibitem

  author empty$

    { format.editors "author and editor" output.check

      editor format.key output

    }

    { format.authors output.nonnull

      crossref missing$

        { "author and editor" editor either.or.check }

        'skip$

      if$

    }

  if$

  format.date "year" output.check

  date.block

  format.btitle "title" output.check

  crossref missing$

    {

      format.bvolume output

      format.chapter.pages "chapter and pages" output.check

      new.block

      format.number.series output

      new.sentence

      format.publisher.address output

    }

    {

      format.chapter.pages "chapter and pages" output.check

      new.block

      format.book.crossref output.nonnull

    }

  if$

  format.edition output

  new.block

  format.note output

  fin.entry

  write.url

}



FUNCTION {incollection}

{ output.bibitem

  format.authors "author" output.check

  author format.key output

  format.date "year" output.check

  date.block

  format.title "title" output.check

  new.block

  crossref missing$

    { format.in.ed.booktitle "booktitle" output.check

      format.bvolume output

      format.number.series output

      format.chapter.pages output

      new.sentence

      format.publisher.address output

      format.edition output

    }

    { format.incoll.inproc.crossref output.nonnull

      format.chapter.pages output

    }

  if$

  new.block

  format.note output

  fin.entry

  write.url

}



FUNCTION {inproceedings}

{ output.bibitem

  format.authors "author" output.check

  author format.key output

  format.date "year" output.check

  date.block

  format.title "title" output.check

  new.block

  crossref missing$

    { format.in.ed.booktitle "booktitle" output.check

      format.bvolume output

      format.number.series output

      format.pages output

      new.sentence

      publisher empty$

        { format.organization.address output }

        { organization output

          format.publisher.address output

        }

      if$

    }

    { format.incoll.inproc.crossref output.nonnull

      format.pages output

    }

  if$

  new.block

  format.note output

  fin.entry

  write.url

}



FUNCTION {conference} { inproceedings }



FUNCTION {manual}

{ output.bibitem

  format.authors output

  author format.key output

  format.date "year" output.check

  date.block

  format.btitle "title" output.check

  organization address new.block.checkb

  organization output

  address output

  format.edition output

  new.block

  format.note output

  fin.entry

  write.url

}



FUNCTION {mastersthesis}

{ output.bibitem

  format.authors "author" output.check

  author format.key output

  format.date "year" output.check

  date.block

  format.btitle "title" output.check

  new.block

  bbl.mthesis format.thesis.type output.nonnull

  school "school" output.check

  address output

  new.block

  format.note output

  fin.entry

  write.url

}



FUNCTION {misc}

{ output.bibitem

  format.authors output

  author format.key output

  format.date "year" output.check

  date.block

  format.title output

  new.block

  howpublished output

  new.block

  format.note output

  fin.entry

  write.url

}



FUNCTION {phdthesis}

{ output.bibitem

  format.authors "author" output.check

  author format.key output

  format.date "year" output.check

  date.block

  format.btitle "title" output.check

  new.block

  bbl.phdthesis format.thesis.type output.nonnull

  school "school" output.check

  address output

  new.block

  format.note output

  fin.entry

  write.url

}



FUNCTION {proceedings}

{ output.bibitem

  format.editors output

  editor format.key output

  format.date "year" output.check

  date.block

  format.btitle "title" output.check

  format.bvolume output

  format.number.series output

  new.sentence

  publisher empty$

    { format.organization.address output }

    { organization output

      format.publisher.address output

    }

  if$

  new.block

  format.note output

  fin.entry

  write.url

}



FUNCTION {techreport}

{ output.bibitem

  format.authors "author" output.check

  author format.key output

  format.date "year" output.check

  date.block

  format.title "title" output.check

  new.block

  format.tr.number output.nonnull

  institution "institution" output.check

  address output

  new.block

  format.note output

  fin.entry

  write.url

}



FUNCTION {unpublished}

{ output.bibitem

  format.authors "author" output.check

  author format.key output

  format.date "year" output.check

  date.block

  format.title "title" output.check

  new.block

  format.note "note" output.check

  fin.entry

  write.url

}



FUNCTION {default.type} { misc }



READ



FUNCTION {sortify}

{ purify$

  "l" change.case$

}



INTEGERS { len }



FUNCTION {chop.word}

{ 's :=

  'len :=

  s #1 len substring$ =

    { s len #1 + global.max$ substring$ }

    's

  if$

}



FUNCTION {format.lab.names}

{ 's :=

  "" 't :=

  s #1 "{vv~}{ll}" format.name$

  s num.names$ duplicate$

  #2 >

    { pop$

      " " * bbl.etal *

    }

    { #2 <

        'skip$

        { s #2 "{ff }{vv }{ll}{ jj}" format.name$ "others" =

            {

              " " * bbl.etal *

            }

            { bbl.and space.word * s #2 "{vv~}{ll}" format.name$

              * }

          if$

        }

      if$

    }

  if$

}



FUNCTION {author.key.label}

{ author empty$

    { key empty$

        { cite$ #1 #3 substring$ }

        'key

      if$

    }

    { author format.lab.names }

  if$

}



FUNCTION {author.editor.key.label}

{ author empty$

    { editor empty$

        { key empty$

            { cite$ #1 #3 substring$ }

            'key

          if$

        }

        { editor format.lab.names }

      if$

    }

    { author format.lab.names }

  if$

}



FUNCTION {editor.key.label}

{ editor empty$

    { key empty$

        { cite$ #1 #3 substring$ }

        'key

      if$

    }

    { editor format.lab.names }

  if$

}



FUNCTION {calc.short.authors}

{ type$ "book" =

  type$ "inbook" =

  or

    'author.editor.key.label

    { type$ "proceedings" =

        'editor.key.label

        'author.key.label

      if$

    }

  if$

  'short.list :=

}



FUNCTION {calc.label}

{ calc.short.authors

  short.list

  "("

  *

  year duplicate$ empty$

  short.list key field.or.null = or

     { pop$ "????" }

     'skip$

  if$

  *

  'label :=

}



FUNCTION {sort.format.names}

{ 's :=

  #1 'nameptr :=

  ""

  s num.names$ 'numnames :=

  numnames 'namesleft :=

    { namesleft #0 > }

    { s nameptr

      "{ll{ }}{  ff{ }}{  jj{ }}"

      format.name$ 't :=

      nameptr #1 >

        {

          "   "  *

          namesleft #1 = t "others" = and

            { "zzzzz" * }

            { numnames #2 > nameptr #2 = and

                { "zz" * year field.or.null * "   " * }

                'skip$

              if$

              t sortify *

            }

          if$

        }

        { t sortify * }

      if$

      nameptr #1 + 'nameptr :=

      namesleft #1 - 'namesleft :=

    }

  while$

}



FUNCTION {sort.format.title}

{ 't :=

  "A " #2

    "An " #3

      "The " #4 t chop.word

    chop.word

  chop.word

  sortify

  #1 global.max$ substring$

}



FUNCTION {author.sort}

{ author empty$

    { key empty$

        { "to sort, need author or key in " cite$ * warning$

          ""

        }

        { key sortify }

      if$

    }

    { author sort.format.names }

  if$

}



FUNCTION {author.editor.sort}

{ author empty$

    { editor empty$

        { key empty$

            { "to sort, need author, editor, or key in " cite$ * warning$

              ""

            }

            { key sortify }

          if$

        }

        { editor sort.format.names }

      if$

    }

    { author sort.format.names }

  if$

}



FUNCTION {editor.sort}

{ editor empty$

    { key empty$

        { "to sort, need editor or key in " cite$ * warning$

          ""

        }

        { key sortify }

      if$

    }

    { editor sort.format.names }

  if$

}



FUNCTION {presort}

{ calc.label

  label sortify

  "    "

  *

  type$ "book" =

  type$ "inbook" =

  or

    'author.editor.sort

    { type$ "proceedings" =

        'editor.sort

        'author.sort

      if$

    }

  if$

  #1 entry.max$ substring$

  'sort.label :=

  sort.label

  *

  "    "

  *

  title field.or.null

  sort.format.title

  *

  #1 entry.max$ substring$

  'sort.key$ :=

}



ITERATE {presort}



SORT



STRINGS { last.label next.extra }



INTEGERS { last.extra.num number.label }



FUNCTION {initialize.extra.label.stuff}

{ #0 int.to.chr$ 'last.label :=

  "" 'next.extra :=

  #0 'last.extra.num :=

  #0 'number.label :=

}



FUNCTION {forward.pass}

{ last.label label =

    { last.extra.num #1 + 'last.extra.num :=

      last.extra.num int.to.chr$ 'extra.label :=

    }

    { "a" chr.to.int$ 'last.extra.num :=

      "" 'extra.label :=

      label 'last.label :=

    }

  if$

  number.label #1 + 'number.label :=

}



FUNCTION {reverse.pass}

{ next.extra "b" =

    { "a" 'extra.label := }

    'skip$

  if$

  extra.label 'next.extra :=

  extra.label

  duplicate$ empty$

    'skip$

    { "{\natexlab{" swap$ * "}}" * }

  if$

  'extra.label :=

  label extra.label * 'label :=

}



EXECUTE {initialize.extra.label.stuff}



ITERATE {forward.pass}



REVERSE {reverse.pass}



FUNCTION {bib.sort.order}

{ sort.label

  "    "

  *

  year field.or.null sortify

  *

  "    "

  *

  title field.or.null

  sort.format.title

  *

  #1 entry.max$ substring$

  'sort.key$ :=

}



ITERATE {bib.sort.order}



SORT



FUNCTION {begin.bib}

{ preamble$ empty$

    'skip$

    { preamble$ write$ newline$ }

  if$

  "\begin{thebibliography}{" number.label int.to.str$ * "}" *

  write$ newline$

  "\expandafter\ifx\csname natexlab\endcsname\relax\def\natexlab#1{#1}\fi"

  write$ newline$

  "\expandafter\ifx\csname url\endcsname\relax"

  write$ newline$

  "  \def\url#1{{\tt #1}}\fi"

  write$ newline$

  "\expandafter\ifx\csname urlprefix\endcsname\relax\def\urlprefix{URL }\fi"

  write$ newline$

}



EXECUTE {begin.bib}



EXECUTE {init.state.consts}



ITERATE {call.type$}



FUNCTION {end.bib}

{ newline$

  "\end{thebibliography}" write$ newline$

}



EXECUTE {end.bib}

%% End of customized bst file

%%

%% End of file `wccfl2.bst'.

