# :nodoc:
 # @api private
489939
def embed_images!(embed, str, layout, valign)
      return [] unless embed.rules.any?
      layout.markup = str
      clean_str     = layout.text
      attrs = layout.attributes || Pango::AttrList.new
      EmbeddingUtils.indices(clean_str, embed.rules.keys).each do |key, ranges|
        rule = embed.rules[key]
        ranges.each do |range|
          carve = Pango::Rectangle.new(0, 0, compute_carve(rule, range), 0)
          att = Pango::AttrShape.new(carve, carve, rule)
          att.start_index = range.first
          att.end_index = range.last
          attrs.insert(att)
        end
      end
      layout.attributes = attrs
      layout.context.set_shape_renderer do |cxt, att, do_path|
        unless do_path # when stroking the text
          rule = att.data
          x = Pango.pixels(layout.index_to_pos(att.start_index).x) +
              rule[:adjust].dx[@index]
          y = Pango.pixels(layout.index_to_pos(att.start_index).y) +
                rule[:adjust].dy[@index] +
                compute_valign(layout, valign, rule[:box].height[@index])
          rule[:draw].call(self, x, y)
          cxt.reset_clip
          [cxt, att, do_path]
        end
      end
    end
767047
def to_h
      hash = {}
      [:bri, :hue, :sat].each do |attr|
        value = send(attr)
        hash[attr] = value if value
      end
      hash
    end
1226314
def canonical
      c = self.local.canonical
      c += "@" + self.host.canonical if self.host.canonical && self.host.canonical > " "
      c
    end
1202382
def _paloadf(ins):
    ''' 
    '''
    output = _paddr(ins.quad[2])
    output.append('call __ILOADF')
    output.extend(_fpush())

    REQUIRES.add('iloadf.asm')

    return output
616950
def virtual_pins(id = nil, options = {}, &block)
      id, options = nil, id if id.is_a?(Hash)
      options = {
        virtual_pin: true
      }.merge(options)
      pins(id, options, &block)
    end
785485
def lookup_without_generate(*args)
      section = @pool

      args.each_with_index do |arg, index|
        section = section[arg]
        return nil unless section
      end

      section
    end
1519
def headers(h = nil)
      if h
        raise ArgumentError, 'Headers must be an object which responds to #to_hash' unless h.respond_to?(:to_hash)
        default_options[:headers] ||= {}
        default_options[:headers].merge!(h.to_hash)
      else
        default_options[:headers] || {}
      end
    end
109641
def mkClusterStatus(num, dirty)
      status = OpenStruct.new
      status.number = num
      status.dirty = dirty
      status
    end
592797
def symbolize(allowed_keys: nil, allowed_vals: nil)
      keys = allowed_keys || self.class.allowed[:keys]
      vals = allowed_vals || self.class.allowed[:vals]

      each_with_object({}) do |(k, v), h|
        k = k.to_sym unless !k.respond_to?(:to_sym) || keys.include?(k.class)
        v = v.to_sym unless !v.respond_to?(:to_sym) || vals.include?(v.class)

        h[k] = !v.respond_to?(:symbolize) ? v : v.symbolize({
          :allowed_keys => allowed_keys,
          :allowed_vals => allowed_vals
        })
      end
    end
253582
function ROR() {
		var value = modRead(),
			result = ( value >>> 1 ) & 0xff;

		result = write( result | (flagC ? 0x80 : 0) );
		flagC = value & 0x01;
		flagZ = +( result === 0 );
		flagN = ( result & 0x80 ) && 1;
	}
657613
def to_app # :nodoc:
      Rack::Builder.new.tap do |app|
        app.use Middleware::Static, machined.output_path
        app.use Middleware::RootIndex
        app.run Rack::URLMap.new(sprockets_map)
      end
    end
182789
def [](key, src = name.to_sym)
      attr =
        if count_index[key].equal?(1)
          name_index[key]
        else
          source_index[src][key]
        end

      unless attr
        raise(KeyError, "#{key.inspect} attribute doesn't exist in #{src} schema")
      end

      attr
    end
1280089
function (mode, code, tokens, flags, scope, parseMode) {
    var index = code.index,
        length = code.length;

    if ( /* <!-- */
        code.codePointAt(index) === 0x003c &&
        code.codePointAt(++index) === 0x0021 &&
        code.codePointAt(++index) === 0x002d &&
        code.codePointAt(++index) === 0x002d
    ) {
        index++;

        for (; index < length; index++) {
            if ( /* --> */
                code.codePointAt(index) === 0x002d &&
                code.codePointAt(index + 1) === 0x002d &&
                code.codePointAt(index + 2) === 0x003e
            ) {
                index += 3;
                code.index = index;

                return true;
            }
        }

        throw code.makeError(
            code.index, code.index + 4,
            'Unclosed Comment: Expected "-->" to fallow "<!--".'
        );
    }

    return null;
}
831858
def status(value = nil)
      response.status = Rack::Utils.status_code(value) if value
      response.status
    end
1262812
def request_setup req_or_uri # :nodoc:
    req = if URI === req_or_uri then
            Net::HTTP::Get.new req_or_uri.request_uri
          else
            req_or_uri
          end

    @headers.each do |pair|
      req.add_field(*pair)
    end

    @override_headers.each do |name, value|
      req[name] = value
    end

    unless req['Connection'] then
      req.add_field 'Connection', 'keep-alive'
      req.add_field 'Keep-Alive', @keep_alive
    end

    req
  end
331200
function closeTop () {
    var ids = Object.keys(vexes)
    if (!ids.length) {
      return false
    }
    return vexes[ids[ids.length - 1]].close()
  }
1174954
def rack_options # :nodoc:
      symbolized_options(:port, :host, :server, :daemonize, :pid).tap do |rack_options|
        rack_options[:environment] = environment
        rack_options[:Port] = rack_options.delete :port
        rack_options[:Host] = rack_options.delete :host
        rack_options[:app] = machined
      end
    end