%%

%% This is file `out.bst',

%% generated with the docstrip utility.

%%

%% The original source files were:

%%

%% merlin.mbs  (with options: `alph,nm-init,ed-au,num-xser,isbn,issn,doi,xedn,nfss,')

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

%% ***  ***

%% 

%% Copyright 1994-2004 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}[2004/02/09 4.13 (PWD, AO, DPC)]

 %   For use with BibTeX version 0.99a or later

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

 % This bibliography style file is intended for texts in ENGLISH

 % This is a labelled citation style similar to the standard alpha.bst,

 %   where labels are of the form Dal90 or DBK89.

 % It requires no extra package to interface to the main text.

 % The form of the \bibitem entries is

 %   \bibitem[label]{key}...

 % Usage of \cite is as follows:

 %   \cite{key} ==>>          [label]

 %   \cite[chap. 2]{key} ==>> [label, chap. 2]

 % The order in the reference list is by label.

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

ENTRY

  { address

    author

    booktitle

    chapter

    doi

    edition

    editor

    eid

    howpublished

    institution

    isbn

    issn

    journal

    key

    month

    note

    number

    organization

    pages

    publisher

    school

    series

    title

    type

    volume

    year

  }

  {}

  { label extra.label sort.label }

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.checka}

{ empty$

    'skip$

    'new.block

  if$

}

FUNCTION {new.block.checkb}

{ empty$

  swap$ empty$

  and

    'skip$

    'new.block

  if$

}

FUNCTION {new.sentence.checka}

{ empty$

    'skip$

    'new.sentence

  if$

}

FUNCTION {new.sentence.checkb}

{ empty$

  swap$ empty$

  and

    'skip$

    'new.sentence

  if$

}

FUNCTION {field.or.null}

{ duplicate$ empty$

    { pop$ "" }

    'skip$

  if$

}

FUNCTION {emphasize}

{ duplicate$ empty$

    { pop$ "" }

    { "\emph{" swap$ * "}" * }

  if$

}

FUNCTION {tie.or.space.prefix}

{ duplicate$ text.length$ #3 <

    { "~" }

    { " " }

  if$

  swap$

}

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}

{ "pages" }

FUNCTION {bbl.page}

{ "page" }

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 {bibinfo.check}

{ swap$

  duplicate$ missing$

    {

      pop$ pop$

      ""

    }

    { duplicate$ empty$

        {

          swap$ pop$

        }

        { swap$

          pop$

        }

      if$

    }

  if$

}

FUNCTION {bibinfo.warn}

{ swap$

  duplicate$ missing$

    {

      swap$ "missing " swap$ * " in " * cite$ * warning$ pop$

      ""

    }

    { duplicate$ empty$

        {

          swap$ "empty " swap$ * " in " * cite$ * warning$

        }

        { swap$

          pop$

        }

      if$

    }

  if$

}

STRINGS  { bibinfo}

INTEGERS { nameptr namesleft numnames }

FUNCTION {format.names}

{ 'bibinfo :=

  duplicate$ empty$ 'skip$ {

  's :=

  "" 't :=

  #1 'nameptr :=

  s num.names$ 'numnames :=

  numnames 'namesleft :=

    { namesleft #0 > }

    { s nameptr

      "{f.~}{vv~}{ll}{, jj}"

      format.name$

      bibinfo bibinfo.check

      't :=

      nameptr #1 >

        {

          namesleft #1 >

            { ", " * t * }

            {

              numnames #2 >

                { "," * }

                'skip$

              if$

              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$

  } if$

}

FUNCTION {format.names.ed}

{

  format.names

}

FUNCTION {format.authors}

{ author "author" format.names

}

FUNCTION {get.bbl.editor}

{ editor num.names$ #1 > 'bbl.editors 'bbl.editor if$ }

FUNCTION {format.editors}

{ editor "editor" format.names duplicate$ empty$ 'skip$

    {

      "," *

      " " *

      get.bbl.editor

      *

    }

  if$

}

FUNCTION {format.isbn}

{ isbn "isbn" bibinfo.check

  duplicate$ empty$ 'skip$

    {

      new.block

      "ISBN " swap$ *

    }

  if$

}

FUNCTION {format.issn}

{ issn "issn" bibinfo.check

  duplicate$ empty$ 'skip$

    {

      new.block

      "ISSN " swap$ *

    }

  if$

}

FUNCTION {format.doi}

{ doi "doi" bibinfo.check

  duplicate$ empty$ 'skip$

    {

      new.block

      "\doi{" swap$ * "}" *

    }

  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$ * "note" bibinfo.check

    }

  if$

}

FUNCTION {format.title}

{ title

  duplicate$ empty$ 'skip$

    { "t" change.case$ }

  if$

  "title" bibinfo.check

}

FUNCTION {output.bibitem}

{ newline$

  "\bibitem[" label * "]{" * write$

  cite$ write$

  "}" write$

  newline$

  ""

  before.all 'output.state :=

}

FUNCTION {n.dashify}

{

  '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}

{

  month "month" bibinfo.check

  duplicate$ empty$

  year  "year"  bibinfo.check duplicate$ empty$

    { swap$ 'skip$

        { "there's a month but no year in " cite$ * warning$ }

      if$

      *

    }

    { swap$ 'skip$

        {

          swap$

          " " * swap$

        }

      if$

      *

    }

  if$

}

FUNCTION {format.btitle}

{ title "title" bibinfo.check

  duplicate$ empty$ 'skip$

    {

      emphasize

    }

  if$

}

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.prefix

      "volume" bibinfo.check * *

      series "series" bibinfo.check

      duplicate$ empty$ 'pop$

        { swap$ bbl.of space.word * swap$

          emphasize * }

      if$

      "volume and number" number either.or.check

    }

  if$

}

FUNCTION {format.number.series}

{ volume empty$

    { number empty$

        { series field.or.null }

        { series empty$

            { number "number" bibinfo.check }

            { output.state mid.sentence =

                { bbl.number }

                { bbl.number capitalize }

              if$

              number tie.or.space.prefix "number" bibinfo.check * *

              bbl.in space.word *

              series "series" bibinfo.check *

            }

          if$

        }

      if$

    }

    { "" }

  if$

}

FUNCTION {format.edition}

{ edition duplicate$ empty$ 'skip$

    {

      output.state mid.sentence =

        { "l" }

        { "t" }

      if$ change.case$

      "edition" bibinfo.check

      " " * bbl.edition *

    }

  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 duplicate$ empty$ 'skip$

    { duplicate$ multi.page.check

        {

          bbl.pages swap$

          n.dashify

        }

        {

          bbl.page swap$

        }

      if$

      tie.or.space.prefix

      "pages" bibinfo.check

      * *

    }

  if$

}

FUNCTION {format.journal.pages}

{ pages duplicate$ empty$ 'pop$

    { swap$ duplicate$ empty$

        { pop$ pop$ format.pages }

        {

          ":" *

          swap$

          n.dashify

          "pages" bibinfo.check

          *

        }

      if$

    }

  if$

}

FUNCTION {format.journal.eid}

{ eid "eid" bibinfo.check

  duplicate$ empty$ 'pop$

    { swap$ duplicate$ empty$ 'skip$

      {

          ":" *

      }

      if$

      swap$ *

    }

  if$

}

FUNCTION {format.vol.num.pages}

{ volume field.or.null

  duplicate$ empty$ 'skip$

    {

      "volume" bibinfo.check

    }

  if$

  number "number" bibinfo.check duplicate$ empty$ 'skip$

    {

      swap$ duplicate$ empty$

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

        'skip$

      if$

      swap$

      "(" swap$ * ")" *

    }

  if$ *

  eid empty$

    { format.journal.pages }

    { format.journal.eid }

  if$

}

FUNCTION {format.chapter.pages}

{ chapter empty$

    'format.pages

    { type empty$

        { bbl.chapter }

        { type "l" change.case$

          "type" bibinfo.check

        }

      if$

      chapter tie.or.space.prefix

      "chapter" bibinfo.check

      * *

      pages empty$

        'skip$

        { ", " * format.pages * }

      if$

    }

  if$

}

FUNCTION {format.booktitle}

{

  booktitle "booktitle" bibinfo.check

  emphasize

}

FUNCTION {format.in.ed.booktitle}

{ format.booktitle duplicate$ empty$ 'skip$

    {

      editor "editor" format.names.ed duplicate$ empty$ 'pop$

        {

          "," *

          " " *

          get.bbl.editor

          ", " *

          * swap$

          * }

      if$

      word.in swap$ *

    }

  if$

}

FUNCTION {empty.misc.check}

{ author empty$ title empty$ howpublished empty$

  month empty$ year empty$ note empty$

  and and and and and

  key empty$ not and

    { "all relevant fields are empty in " cite$ * warning$ }

    'skip$

  if$

}

FUNCTION {format.thesis.type}

{ type duplicate$ empty$

    'pop$

    { swap$ pop$

      "t" change.case$ "type" bibinfo.check

    }

  if$

}

FUNCTION {format.tr.number}

{ number "number" bibinfo.check

  type duplicate$ empty$

    { pop$ bbl.techrep }

    'skip$

  if$

  "type" bibinfo.check

  swap$ duplicate$ empty$

    { pop$ "t" change.case$ }

    { tie.or.space.prefix * * }

  if$

}

FUNCTION {format.article.crossref}

{

  key duplicate$ empty$

    { pop$

      journal duplicate$ empty$

        { "need key or journal for " cite$ * " to crossref " * crossref * warning$ }

        { "journal" bibinfo.check emphasize word.in swap$ * }

      if$

    }

    { word.in swap$ * " " *}

  if$

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

}

FUNCTION {format.crossref.editor}

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

  "editor" bibinfo.check

  editor num.names$ duplicate$

  #2 >

    { pop$

      "editor" bibinfo.check

      " " * bbl.etal

      *

    }

    { #2 <

        'skip$

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

            {

              "editor" bibinfo.check

              " " * bbl.etal

              *

            }

            {

             bbl.and space.word

              * editor #2 "{vv~}{ll}" format.name$

              "editor" bibinfo.check

              *

            }

          if$

        }

      if$

    }

  if$

}

FUNCTION {format.book.crossref}

{ volume duplicate$ empty$

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

      pop$ word.in

    }

    { bbl.volume

      capitalize

      swap$ tie.or.space.prefix "volume" bibinfo.check * * bbl.of space.word *

    }

  if$

  editor empty$

  editor field.or.null author field.or.null =

  or

    { key empty$

        { series empty$

            { "need editor, key, or series for " cite$ * " to crossref " *

              crossref * warning$

              "" *

            }

            { series emphasize * }

          if$

        }

        { key * }

      if$

    }

    { format.crossref.editor * }

  if$

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

}

FUNCTION {format.incoll.inproc.crossref}

{

  editor empty$

  editor field.or.null author field.or.null =

  or

    { key empty$

        { format.booktitle duplicate$ empty$

            { "need editor, key, or booktitle for " cite$ * " to crossref " *

              crossref * warning$

            }

            { word.in swap$ * }

          if$

        }

        { word.in key * " " *}

      if$

    }

    { word.in format.crossref.editor * " " *}

  if$

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

}

FUNCTION {format.org.or.pub}

{ 't :=

  ""

  address empty$ t empty$ and

    'skip$

    {

      t empty$

        { address "address" bibinfo.check *

        }

        { t *

          address empty$

            'skip$

            { ", " * address "address" bibinfo.check * }

          if$

        }

      if$

    }

  if$

}