# File yaml.rb, line 293
        def YAML.add_builtin_type( type_re, &transfer_proc )
            @@loader.add_builtin_type( type_re, &transfer_proc )
        end

# File yaml.rb, line 286
        def YAML.add_domain_type( domain, type_re, &transfer_proc )
        @@loader.add_domain_type( domain, type_re, &transfer_proc )
        end

# File yaml.rb, line 307
        def YAML.add_private_type( type_re, &transfer_proc )
            @@loader.add_private_type( type_re, &transfer_proc )
        end

# File yaml.rb, line 300
        def YAML.add_ruby_type( type, &transfer_proc )
        @@loader.add_ruby_type( type, &transfer_proc )
        end

# File yaml.rb, line 314
    def YAML.detect_implicit( val )
        @@loader.detect_implicit( val )
    end

# File yaml.rb, line 101
        def YAML.dump( obj, io = nil )
        io ||= ""
        io << obj.to_yaml
        io
        end

# File yaml.rb, line 275
        def YAML.dump_stream( *objs )
                d = YAML::Stream.new
        objs.each do |doc|
                        d.add( doc ) 
        end
        d.emit
        end

# File yaml.rb, line 202
        def YAML.each_document( io, &block )
                yp = @@parser.new.load_documents( io, &block )
    end

# File yaml.rb, line 232
        def YAML.each_node( io, &doc_proc )
                yp = @@parser.new( :Model => :Generic ).load_documents( io, &doc_proc )
    end

# File yaml/encoding.rb, line 10
        def YAML.escape( value, skip = "" )
                value.gsub( /\\/, "\\\\\\" ).
              gsub( /"/, "\\\"" ).
              gsub( /([\x00-\x1f])/ ) do |x|
                 skip[x] || ESCAPES[ x.unpack("C")[0] ]
             end
        end

# File yaml.rb, line 118
        def YAML.load( io )
                yp = @@parser.new.load( io )
        end

# File yaml.rb, line 217
        def YAML.load_documents( io, &doc_proc )
                YAML.each_document( io, &doc_proc )
    end

# File yaml.rb, line 128
    def YAML.load_file( filepath )
        File.open( filepath ) do |f|
            load( f )
        end
    end

# File yaml.rb, line 256
        def YAML.load_stream( io )
                yp = @@parser.new
                d = nil
                yp.load_documents( io ) { |doc|
                        d = YAML::Stream.new( yp.options ) if not d
                        d.add( doc ) 
                }
                return d
        end

# File yaml/stringio.rb, line 55
        def YAML.make_stream( io )
        if String === io
            io = StringIO.new( io )
        elsif not IO === io
            raise YAML::Error, "YAML stream must be an IO or String object."
        end
        if YAML::unicode
            def io.readline
                YAML.utf_to_internal( readline( @ln_sep ), @utf_encoding )
            end
            def io.check_unicode
                @utf_encoding = YAML.sniff_encoding( read( 4 ) )
                @ln_sep = YAML.enc_separator( @utf_encoding )
                seek( -4, IO::SEEK_CUR )
            end
                    def io.utf_encoding
                      @utf_encoding
                    end
            io.check_unicode
        else
            def io.utf_encoding
                :None
            end
        end
        io
        end

# File yaml.rb, line 345
    def YAML.object_maker( obj_class, val )
        if Hash === val
            o = obj_class.allocate
            val.each_pair { |k,v|
                o.instance_variable_set("@#{k}", v)
            }
            o
        else
            raise YAML::Error, "Invalid object explicitly tagged !ruby/Object: " + val.inspect
        end
    end

# File yaml.rb, line 161
        def YAML.parse( io )
                yp = @@parser.new( :Model => :Generic ).load( io )
        end

# File yaml.rb, line 247
        def YAML.parse_documents( io, &doc_proc )
                YAML.each_node( io, &doc_proc )
    end

# File yaml.rb, line 185
    def YAML.parse_file( filepath )
        File.open( filepath ) do |f|
            parse( f )
        end
    end

# File yaml.rb, line 360
        def YAML.quick_emit( oid, opts = {}, &e )
                old_opt = nil
                if opts[:Emitter].is_a? @@emitter
                        out = opts.delete( :Emitter )
                        old_opt = out.options.dup
                        out.options.update( opts )
                else
                        out = @@emitter.new( opts )
                end
        aidx = out.start_object( oid )
        if aidx
            out.simple( "*#{ aidx }" )
        else
            e.call( out )
        end
                if old_opt.is_a? Hash
                        out.options = old_opt
                end 
                out.end_object
        end

# File yaml.rb, line 336
    def YAML.read_type_class( type, obj_class )
        scheme, domain, type, tclass = type.split( ':', 4 )
        tclass.split( "::" ).each { |c| obj_class = obj_class.const_get( c ) } if tclass
        return [ type, obj_class ]
    end

# File yaml.rb, line 321
    def YAML.transfer( type_id, obj )
        @@loader.transfer( type_id, obj )
    end

# File yaml.rb, line 328
        def YAML.try_implicit( obj )
                YAML.transfer( YAML.detect_implicit( obj ), obj )
        end

# File yaml/encoding.rb, line 21
        def YAML.unescape( value )
                value.gsub( /\\(?:([nevfbart\\])|0?x([0-9a-fA-F]{2})|u([0-9a-fA-F]{4}))/ ) { |x| 
                        if $3
                                ["#$3".hex ].pack('U*')
                        elsif $2
                                [$2].pack( "H2" ) 
                        else
                                UNESCAPES[$1] 
                        end
                }
        end