# File lib/domain_name/punycode.rb, line 105
      def encode(string)
        input = string.unpack('U*')
        output = ''

        # Initialize the state
        n = INITIAL_N
        delta = 0
        bias = INITIAL_BIAS

        # Handle the basic code points
        input.each { |cp| output << cp.chr if cp < 0x80 }

        h = b = output.length

        # h is the number of code points that have been handled, b is the
        # number of basic code points, and out is the number of characters
        # that have been output.

        output << DELIMITER if b > 0

        # Main encoding loop

        while h < input.length
          # All non-basic code points < n have been handled already.  Find
          # the next larger one

          m = MAXINT
          input.each { |cp|
            m = cp if (n...m) === cp
          }

          # Increase delta enough to advance the decoder's <n,i> state to
          # <m,0>, but guard against overflow

          delta += (m - n) * (h + 1)
          raise BufferOverflowError if delta > MAXINT
          n = m

          input.each { |cp|
            # AMC-ACE-Z can use this simplified version instead
            if cp < n
              delta += 1
              raise BufferOverflowError if delta > MAXINT
            elsif cp == n
              # Represent delta as a generalized variable-length integer
              q = delta
              k = BASE
              loop {
                t = k <= bias ? TMIN : k - bias >= TMAX ? TMAX : k - bias
                break if q < t
                q, r = (q - t).divmod(BASE - t)
                output << encode_digit(t + r, false)
                k += BASE
              }

              output << encode_digit(q, false)

              # Adapt the bias
              delta = h == b ? delta / DAMP : delta >> 1
              delta += delta / (h + 1)
              bias = 0
              while delta > CUTOFF
                delta /= LOBASE
                bias += BASE
              end
              bias += (LOBASE + 1) * delta / (delta + SKEW)

              delta = 0
              h += 1
            end
          }

          delta += 1
          n += 1
        end

        output
      end