def find!( line, opts={} )

    ### fix: add and match all-in-one literal first, followed by

    # note: always call after find_dates !!!
    #  scores match date-like patterns!!  e.g. 10-11  or 10:00 etc.
    #   -- note: score might have two digits too

    ### fix: depending on language allow 1:1 or 1-1
    ##   do NOT allow mix and match
    ##  e.g. default to en is  1-1
    ##    de is 1:1 etc.


    # extract score from line
    # and return it
    # note: side effect - removes date from line string


    score1i   = nil    # half time (ht) scores
    score2i   = nil

    score1   = nil    # full time (ft) scores
    score2   = nil

    score1et = nil    # extra time (et) scores
    score2et = nil

    score1p  = nil   # penalty (p) scores
    score2p  = nil


    if (md = EN__P_ET_FT_HT__REGEX.match( line ))
      score1i   = md[:score1i].to_i
      score2i   = md[:score2i].to_i
      score1    = md[:score1].to_i
      score2    = md[:score2].to_i
      score1et  = md[:score1et].to_i
      score2et  = md[:score2et].to_i
      score1p   = md[:score1p].to_i
      score2p   = md[:score2p].to_i

      logger.debug "   score.en__p_et_ft_ht: >#{score1p}-#{score2p} pen. #{score1et}-#{score2et} a.e.t. (#{score1}-#{score2}, #{score1i}-#{score2i})<"

      line.sub!( md[0], '[SCORES.EN__P_ET_FT_HT]' )

    elsif (md = EN__ET_FT_HT__REGEX.match( line ))
      score1i   = md[:score1i].to_i
      score2i   = md[:score2i].to_i
      score1    = md[:score1].to_i
      score2    = md[:score2].to_i
      score1et  = md[:score1et].to_i
      score2et  = md[:score2et].to_i

      logger.debug "   score.en__et_ft_ht: >#{score1et}-#{score2et} a.e.t. (#{score1}-#{score2}, #{score1i}-#{score2i})<"

      line.sub!( md[0], '[SCORES.EN__ET_FT_HT]' )

    elsif (md = EN__FT_HT__REGEX.match( line ))
      score1i = md[:score1i].to_i
      score2i = md[:score2i].to_i
      score1  = md[:score1].to_i
      score2  = md[:score2].to_i

      logger.debug "   score.en__ft_ht: >#{score1}-#{score2} (#{score1i}-#{score2i})<"

      line.sub!( md[0], '[SCORES.EN__FT_HT]' )
    else
      #######################################################
      ## try "standard" generic patterns for fallbacks

      if (md = ET_REGEX.match( line ))
        score1et = md[:score1].to_i
        score2et = md[:score2].to_i

        logger.debug "   score.et: >#{score1et}-#{score2et}<"

        line.sub!( md[0], '[SCORE.ET]' )
      end

      if (md = P_REGEX.match( line ))
        score1p = md[:score1].to_i
        score2p = md[:score2].to_i

        logger.debug "   score.p: >#{score1p}-#{score2p}<"

        line.sub!( md[0], '[SCORE.P]' )
      end

      ## let full time (ft) standard regex go last - has no marker

      if (md = FT_REGEX.match( line ))
        score1 = md[:score1].to_i
        score2 = md[:score2].to_i

        logger.debug "   score: >#{score1}-#{score2}<"

        line.sub!( md[0], '[SCORE]' )
      end
    end

    ## todo: how to handle game w/o extra time
    #   but w/ optional penalty ???  e.g. used in copa liberatores, for example
    #    retrun 0,0 or nil,nil for extra time score ?? or -1, -1 ??
    #    for now use nil,nil

    scores = []
    scores += [score1i, score2i]     if score1p || score2p || score1et || score2et || score1 || score2 || score1i || score2i
    scores += [score1, score2]       if score1p || score2p || score1et || score2et || score1 || score2
    scores += [score1et, score2et]   if score1p || score2p || score1et || score2et
    scores += [score1p,  score2p]    if score1p || score2p

    scores
  end
def find!( line, opts={} )

    ### fix: add and match all-in-one literal first, followed by

    # note: always call after find_dates !!!
    #  scores match date-like patterns!!  e.g. 10-11  or 10:00 etc.
    #   -- note: score might have two digits too

    ### fix: depending on language allow 1:1 or 1-1
    ##   do NOT allow mix and match
    ##  e.g. default to en is  1-1
    ##    de is 1:1 etc.


    # extract score from line
    # and return it
    # note: side effect - removes date from line string


    score1i   = nil    # half time (ht) scores
    score2i   = nil

    score1   = nil    # full time (ft) scores
    score2   = nil

    score1et = nil    # extra time (et) scores
    score2et = nil

    score1p  = nil   # penalty (p) scores
    score2p  = nil


    if (md = EN__P_ET_FT_HT__REGEX.match( line ))
      score1i   = md[:score1i].to_i
      score2i   = md[:score2i].to_i
      score1    = md[:score1].to_i
      score2    = md[:score2].to_i
      score1et  = md[:score1et].to_i
      score2et  = md[:score2et].to_i
      score1p   = md[:score1p].to_i
      score2p   = md[:score2p].to_i

      logger.debug "   score.en__p_et_ft_ht: >#{score1p}-#{score2p} pen. #{score1et}-#{score2et} a.e.t. (#{score1}-#{score2}, #{score1i}-#{score2i})<"

      line.sub!( md[0], '[SCORES.EN__P_ET_FT_HT]' )

    elsif (md = EN__ET_FT_HT__REGEX.match( line ))
      score1i   = md[:score1i].to_i
      score2i   = md[:score2i].to_i
      score1    = md[:score1].to_i
      score2    = md[:score2].to_i
      score1et  = md[:score1et].to_i
      score2et  = md[:score2et].to_i

      logger.debug "   score.en__et_ft_ht: >#{score1et}-#{score2et} a.e.t. (#{score1}-#{score2}, #{score1i}-#{score2i})<"

      line.sub!( md[0], '[SCORES.EN__ET_FT_HT]' )

    elsif (md = EN__FT_HT__REGEX.match( line ))
      score1i = md[:score1i].to_i
      score2i = md[:score2i].to_i
      score1  = md[:score1].to_i
      score2  = md[:score2].to_i

      logger.debug "   score.en__ft_ht: >#{score1}-#{score2} (#{score1i}-#{score2i})<"

      line.sub!( md[0], '[SCORES.EN__FT_HT]' )
    else
      #######################################################
      ## try "standard" generic patterns for fallbacks

      if (md = ET_REGEX.match( line ))
        score1et = md[:score1].to_i
        score2et = md[:score2].to_i

        logger.debug "   score.et: >#{score1et}-#{score2et}<"

        line.sub!( md[0], '[SCORE.ET]' )
      end

      if (md = P_REGEX.match( line ))
        score1p = md[:score1].to_i
        score2p = md[:score2].to_i

        logger.debug "   score.p: >#{score1p}-#{score2p}<"

        line.sub!( md[0], '[SCORE.P]' )
      end

      ## let full time (ft) standard regex go last - has no marker

      if (md = FT_REGEX.match( line ))
        score1 = md[:score1].to_i
        score2 = md[:score2].to_i

        logger.debug "   score: >#{score1}-#{score2}<"

        line.sub!( md[0], '[SCORE]' )
      end
    end

    ## todo: how to handle game w/o extra time
    #   but w/ optional penalty ???  e.g. used in copa liberatores, for example
    #    retrun 0,0 or nil,nil for extra time score ?? or -1, -1 ??
    #    for now use nil,nil

    scores = []
    scores += [score1i, score2i]     if score1p || score2p || score1et || score2et || score1 || score2 || score1i || score2i
    scores += [score1, score2]       if score1p || score2p || score1et || score2et || score1 || score2
    scores += [score1et, score2et]   if score1p || score2p || score1et || score2et
    scores += [score1p,  score2p]    if score1p || score2p

    scores
  end
todo: allow all-in-one "literal form a la kicker" e.g.
  2:2 (1:1, 1:0) n.V. 5:1 i.E.