test.page.bare

    #   -------------"_--------------- 
    #  "`w^"                           



"WRAPPED_TEXT
WRAPPED_TEXT_line2"

"WRAPPED_TEXT
WRAPPED_TEXT_line2" b

`"WRAPPED_TEXT
WRAPPED_TEXT_line2"^

a "WRAPPED_TEXT
WRAPPED_TEXT_line2"


    #   -------------%--------------- 
    #  %`_^[`^]                       



    %w[]

    %w[_TYPED] b

    `%w[]^

    a %w[]


    #   -------------'_--------------- 
    #  '`w^'                           



'WRAPPED_TEXT
WRAPPED_TEXT_line2'

'WRAPPED_TEXT
WRAPPED_TEXT_line2' b

`'WRAPPED_TEXT
WRAPPED_TEXT_line2'^

a 'WRAPPED_TEXT
WRAPPED_TEXT_line2'


    #   -------------(_--------------- 
    #  (`w^)                           



(WRAPPED_TEXT
WRAPPED_TEXT_line2)

(WRAPPED_TEXT
WRAPPED_TEXT_line2) b

`(WRAPPED_TEXT
WRAPPED_TEXT_line2)^

a (WRAPPED_TEXT
WRAPPED_TEXT_line2)


    #   -------------:--------------- 
    #  :`key^ => `value^              



    :key => value

    :key_TYPED => value b

    `:key => value^

    a :key => value


    #   -------------<_--------------- 
    #  <`w^>                           



<WRAPPED_TEXT
WRAPPED_TEXT_line2>

<WRAPPED_TEXT
WRAPPED_TEXT_line2> b

`<WRAPPED_TEXT
WRAPPED_TEXT_line2>^

a <WRAPPED_TEXT
WRAPPED_TEXT_line2>


    #   -------------[_--------------- 
    #  [`w^]                           



[WRAPPED_TEXT
WRAPPED_TEXT_line2]

[WRAPPED_TEXT
WRAPPED_TEXT_line2] b

`[WRAPPED_TEXT
WRAPPED_TEXT_line2]^

a [WRAPPED_TEXT
WRAPPED_TEXT_line2]


    #   -------------_d--------------- 
    #  __DATA__                        



    __DATA__

    __DATA__ b

    `__DATA__^

    a __DATA__


    #   -------------_e--------------- 
    #  __END__                         



    __END__

    __END__ b

    `__END__^

    a __END__


    #   -------------_f--------------- 
    #  __FILE__                        



    __FILE__

    __FILE__ b

    `__FILE__^

    a __FILE__


    #   -------------`_--------------- 
    #  \``w^\`                         



`WRAPPED_TEXT
WRAPPED_TEXT_line2`

`WRAPPED_TEXT
WRAPPED_TEXT_line2` b

``WRAPPED_TEXT
WRAPPED_TEXT_line2`^

a `WRAPPED_TEXT
WRAPPED_TEXT_line2`


    #   -------------ali--------------- 
    #  alias :`new^ :`old^              



    alias :new :old_new

    alias :new_TYPED :old_TYPED b

    `alias :new :old_new^

    a alias :new :old_new


    #   -------------all--------------- 
    #  all? { |`element^| `cursor^ }    



    all? { |element|  }

    all? { |element_TYPED|  } b

    `all? { |element|  }^

    a all? { |element|  }


    #   -------------amm--------------- 
    #  alias_method :`new^, :`old^      



    alias_method :new, :old_new

    alias_method :new_TYPED, :old_TYPED b

    `alias_method :new, :old_new^

    a alias_method :new, :old_new


    #   -------------any--------------- 
    #  any? { |`element^| `cursor^ }    



    any? { |element|  }

    any? { |element_TYPED|  } b

    `any? { |element|  }^

    a any? { |element|  }


    #   -------------app--------------- 
    #  if __FILE__ == $PROGRAM_NAME     
    #          `cursor^                 
    #  end                              



    if __FILE__ == $PROGRAM_NAME
	    
    end

    if __FILE__ == $PROGRAM_NAME
	    
    end b

    `if __FILE__ == $PROGRAM_NAME
	    
    end^

    a if __FILE__ == $PROGRAM_NAME
	    
    end


    #   -------------array---------------   
    #  Array.new(`size^) { |`i^| `cursor^ } 



    Array.new(size) { |i|  }

    Array.new(size_TYPED) { |i_TYPED|  } b

    `Array.new(size) { |i|  }^

    a Array.new(size) { |i|  }


    #   -------------ass--------------- 
    #  assert`_`what^                   



    assert_block {  }

    assert_block {  } b

    `assert_block {  }^

    a assert_block {  }


    #   -------------attr--------------- 
    #  attr`_`what^ :`attr*^             



    attr_accessor :

    attr_accessor :attr_TYPED, :attr_TYPED, :attr_TYPED b

    `attr_accessor :^

    a attr_accessor :


    #   -------------Author--------------- 
    #  `$author^                           



    drdr.xp

    drdr.xp b

    `drdr.xp^

    a drdr.xp


    #   -------------BEG--------------- 
    #  BEGIN {                          
    #          `cursor^                 
    #  }                                



    BEGIN {
	    
    }

    BEGIN {
	    
    } b

    `BEGIN {
	    
    }^

    a BEGIN {
	    
    }


    #   -------------begin--------------- 
    #  begin                              
    #          `expr^                     
    #  ``rescue...`                       
    #  {{^rescue `Exception^` => `e^      
    #          `block^                    
    #  ``rescue...`                       
    #  ^`}}^``else...`                    
    #  {{^else                            
    #          `block^                    
    #  `}}^``ensure...`                   
    #  {{^ensure                          
    #          `cursor^                   
    #  `}}^end                            



    begin
	    expr
    rescue Exception => e
	    # block
    rescue Exception => e
	    # block
    rescue Exception => e
	    # block
    else
	    # block
    ensure
	    
    end

    begin
	    expr_TYPED
    rescue_TYPED
    else_TYPED
    ensure_TYPED
	end b

	`begin
		expr
	rescue Exception => e
		# block
	rescue Exception => e
		# block
	rescue Exception => e
		# block
	else
		# block
	ensure
		
	end^

	a begin
		expr
	rescue Exception => e
		# block
	rescue Exception => e
		# block
	rescue Exception => e
		# block
	else
		# block
	ensure
		
	end


    #   -------------begin_--------------- 
    #  begin                               
    #          `wrapped^                   
    #  ``rescue...`                        
    #  {{^rescue `Exception^` => `e^       
    #          `block^                     
    #  ``rescue...`                        
    #  ^`}}^``else...`                     
    #  {{^else                             
    #          `block^                     
    #  `}}^``ensure...`                    
    #  {{^ensure                           
    #          `cursor^                    
    #  `}}^end                             



begin
	WRAPPED_TEXT
	WRAPPED_TEXT_line2
rescue Exception => e
	# block
rescue Exception => e
	# block
rescue Exception => e
	# block
else
	# block
ensure
	
end

	begin
		WRAPPED_TEXT
		WRAPPED_TEXT_line2
	rescue_TYPED
	else_TYPED
	ensure_TYPED
		end b

		`begin
			WRAPPED_TEXT
			WRAPPED_TEXT_line2
		rescue Exception => e
			# block
		rescue Exception => e
			# block
		rescue Exception => e
			# block
		else
			# block
		ensure
			
		end^

		a begin
			WRAPPED_TEXT
			WRAPPED_TEXT_line2
		rescue Exception => e
			# block
		rescue Exception => e
			# block
		rescue Exception => e
			# block
		else
			# block
		ensure
			
		end


    #   -------------bm--------------- 
    #  TESTS = `times^                 
    #                                  
    #  Benchmark.bmbm do |result|      
    #          `cursor^                
    #  end                             



    TESTS = 10_000
    
    Benchmark.bmbm do |result|
	    
    end

    TESTS = times_TYPED
    
    Benchmark.bmbm do |result|
	    
    end b

    `TESTS = 10_000
    
    Benchmark.bmbm do |result|
	    
    end^

    a TESTS = 10_000
    
    Benchmark.bmbm do |result|
	    
    end


    #   -------------case--------------- 
    #  case `target^`                    
    #  when `comparison^                 
    #          `block^                   
    #  ``when...`                        
    #  {{^when `comparison^              
    #          `block^                   
    #  ``when...`                        
    #  ^`}}^``else...`                   
    #  {{^else                           
    #          `cursor^                  
    #  `}}^end                           



    case target
    when comparison
	    # block
    when comparison
	    # block
    when comparison
	    # block
    when comparison
	    # block
    else
	    
    end

    case target_TYPED
    when comparison_TYPED
	    block_TYPED
    when_TYPED
    else_TYPED
     end b

     `case target
     when comparison
	     # block
     when comparison
	     # block
     when comparison
	     # block
     when comparison
	     # block
     else
	     
     end^

     a case target
     when comparison
	     # block
     when comparison
	     # block
     when comparison
	     # block
     when comparison
	     # block
     else
	     
     end


    #   -------------cfy---------------  
    #  classify { |`element^| `cursor^ } 



    classify { |element|  }

    classify { |element_TYPED|  } b

    `classify { |element|  }^

    a classify { |element|  }


    #   -------------cl--------------- 
    #  class `ClassName^               
    #          `cursor^                
    #  end                             



    class ClassName
	    
    end

    class ClassNameTYPED
	    
    end b

    `class ClassName
	    
    end^

    a class ClassName
	    
    end


    #   -------------class_--------------- 
    #  class `_^                           
    #          `wrapped^                   
    #  end                                 



class 
	WRAPPED_TEXT
	WRAPPED_TEXT_line2
end

    class TYPED
	    WRAPPED_TEXT
	    WRAPPED_TEXT_line2
    end b

    `class 
	    WRAPPED_TEXT
	    WRAPPED_TEXT_line2
    end^

    a class 
	    WRAPPED_TEXT
	    WRAPPED_TEXT_line2
    end


    #   -------------cld---------------                 
    #  class `ClassName^ < DelegateClass(`ParentClass^) 
    #          def initialize`(`arg*`)^                 
    #                  super(`delegate object^)         
    #                                                   
    #                  `cursor^                         
    #          end                                      
    #  end                                              



    class ClassName < DelegateClass(ParentClass)
	    def initialize
		    super(delegate object)
    
		    
	    end
    end

    class ClassNameTYPED < DelegateClass(ParentClassTYPED)
	    def initialize(arg_TYPED, narg_TYPED, narg_TYPED)
		    super(delegateobject_TYPED)
    
		    
	    end
    end b

    `class ClassName < DelegateClass(ParentClass)
	    def initialize
		    super(delegate object)
    
		    
	    end
    end^

    a class ClassName < DelegateClass(ParentClass)
	    def initialize
		    super(delegate object)
    
		    
	    end
    end


    #   -------------cli--------------- 
    #  class `ClassName^                
    #          `init^`                  
    #          `def...^                 
    #                                   
    #          `def^`                   
    #          `def...^                 
    #  end                              



    class ClassName
	    def initialize
		    
	    end
    
	    def method
		    
	    end
    end

    class ClassNameTYPED
	    def initialize(arg_TYPED, narg_TYPED, narg_TYPED)
		    init_TYPED
	    end
    	    def_TYPED
    end b

    `class ClassName
	    def initialize
		    
	    end
    
	    def method
		    
	    end
    end^

    a class ClassName
	    def initialize
		    
	    end
    
	    def method
		    
	    end
    end


    #   -------------cls--------------- 
    #  class << `self^                  
    #          `cursor^                 
    #  end                              



    class << self
	    
    end

    class << self_TYPED
	    
    end b

    `class << self
	    
    end^

    a class << self
	    
    end


    #   -------------clstr---------------            
    #  `ClassName^ = Struct.new`(:`attr*`)^` `do...^ 



    ClassName = Struct.new do
	    
    end

    ClassNameTYPED = Struct.new(:attr_TYPED, :nattr_TYPED, :nattr_TYPED) do_TYPED b

    `ClassName = Struct.new do
	    
    end^

    a ClassName = Struct.new do
	    
    end


    #   -------------col--------------- 
    #  collect { |`obj^| `cursor^ }     



    collect { |obj|  }

    collect { |obj_TYPED|  } b

    `collect { |obj|  }^

    a collect { |obj|  }


    #   -------------Comp--------------- 
    #  include Comparable                
    #                                    
    #  def <=>(other)                    
    #          `cursor^                  
    #  end                               



    include Comparable
    
    def <=>(other)
	    
    end

    include Comparable
    
    def <=>(other)
	    
    end b

    `include Comparable
    
    def <=>(other)
	    
    end^

    a include Comparable
    
    def <=>(other)
	    
    end


    #   -------------deec--------------- 
    #  Marshal.load(Marshal.dump(`obj^)) 



    Marshal.load(Marshal.dump(obj))

    Marshal.load(Marshal.dump(obj_TYPED)) b

    `Marshal.load(Marshal.dump(obj))^

    a Marshal.load(Marshal.dump(obj))


    #   -------------def--------------- 
    #  def `method^`(`arg*`)^           
    #          `cursor^                 
    #  end                              



    def method
	    
    end

    def method_TYPED(arg_TYPED, narg_TYPED, narg_TYPED)
	    
    end b

    `def method
	    
    end^

    a def method
	    
    end


    #   -------------def_--------------- 
    #  def `method_name^`(`arg*`)^       
    #          `wrapped^                 
    #  end                               



def method_name
	WRAPPED_TEXT
	WRAPPED_TEXT_line2
end

    def method_name_TYPED(arg_TYPED, narg_TYPED, narg_TYPED)
	    WRAPPED_TEXT
	    WRAPPED_TEXT_line2
    end b

    `def method_name
	    WRAPPED_TEXT
	    WRAPPED_TEXT_line2
    end^

    a def method_name
	    WRAPPED_TEXT
	    WRAPPED_TEXT_line2
    end


    #   -------------defd---------------                  
    #  def_delegator :`del obj^, :`del meth^, :`new name^ 



    def_delegator :del obj, :del meth, :new name

    def_delegator :delobj_TYPED, :delmeth_TYPED, :new name b

    `def_delegator :del obj, :del meth, :new name^

    a def_delegator :del obj, :del meth, :new name


    #   -------------defds---------------        
    #  def_delegators :`del obj^, :`del methods^ 



    def_delegators :del obj, :del methods

    def_delegators :delobj_TYPED, :del methods b

    `def_delegators :del obj, :del methods^

    a def_delegators :del obj, :del methods


    #   -------------defi--------------- 
    #  def initialize`(`arg*`)^          
    #          `cursor^                  
    #  end                               



    def initialize
	    
    end

    def initialize(arg_TYPED, narg_TYPED, narg_TYPED)
	    
    end b

    `def initialize
	    
    end^

    a def initialize
	    
    end


    #   -------------defmm---------------      
    #  def method_missing(meth, *args, &block) 
    #          `cursor^                        
    #  end                                     



    def method_missing(meth, *args, &block)
	    
    end

    def method_missing(meth, *args, &block)
	    
    end b

    `def method_missing(meth, *args, &block)
	    
    end^

    a def method_missing(meth, *args, &block)
	    
    end


    #   -------------defs--------------- 
    #  def self.`method^`(`arg*`)^       
    #          `cursor^                  
    #  end                               



    def self.method
	    
    end

    def self.method_TYPED(arg_TYPED, narg_TYPED, narg_TYPED)
	    
    end b

    `def self.method
	    
    end^

    a def self.method
	    
    end


    #   -------------deft--------------- 
    #  def test_`name^                   
    #          `cursor^                  
    #  end                               



    def test_name
	    
    end

    def test_name_TYPED
	    
    end b

    `def test_name
	    
    end^

    a def test_name
	    
    end


    #   -------------deli--------------- 
    #  delete_if { |`arg^| `cursor^ }    



    delete_if { |arg|  }

    delete_if { |arg_TYPED|  } b

    `delete_if { |arg|  }^

    a delete_if { |arg|  }


    #   -------------det--------------- 
    #  detect { |`obj^| `cursor^ }      



    detect { |obj|  }

    detect { |obj_TYPED|  } b

    `detect { |obj|  }^

    a detect { |obj|  }


    #   -------------dir--------------- 
    #  Dir[`_^]                         



    Dir['/**/*']

    Dir[__TYPED] b

    `Dir['/**/*']^

    a Dir['/**/*']


    #   -------------dirg---------------     
    #  Dir.glob(`dir^) { |`file^| `cursor^ } 



    Dir.glob(dir) { |file|  }

    Dir.glob(dir_TYPED) { |file_TYPED|  } b

    `Dir.glob(dir) { |file|  }^

    a Dir.glob(dir) { |file|  }


    #   -------------do--------------- 
    #  do` |`arg*`|^                   
    #          `cursor^                
    #  end                             



    do
	    
    end

    do |arg_TYPED, narg_TYPED, narg_TYPED|
	    
    end b

    `do
	    
    end^

    a do
	    
    end


    #   -------------dow---------------      
    #  downto(`lbound^) { |`arg^| `cursor^ } 



    downto(0) { |i|  }

    downto(lbound_TYPED) { |arg_TYPED|  } b

    `downto(0) { |i|  }^

    a downto(0) { |i|  }


    #   -------------each---------------  
    #  each`_`what^ { |`vars^| `cursor^ } 



    each_byte { |byte|  }

    each_byte { |byte_TYPED|  } b

    `each_byte { |byte|  }^

    a each_byte { |byte|  }


    #   -------------Email--------------- 
    #  `$email^                           



    drdr.xp@gmail.com

    drdr.xp@gmail.com b

    `drdr.xp@gmail.com^

    a drdr.xp@gmail.com


    #   -------------END--------------- 
    #  END {                            
    #          `cursor^                 
    #  }                                



    END {
	    
    }

    END {
	    
    } b

    `END {
	    
    }^

    a END {
	    
    }


    #   -------------Enum--------------- 
    #  include Enumerable                
    #                                    
    #  def each(&block)                  
    #          `cursor^                  
    #  end                               



    include Enumerable
    
    def each(&block)
	    
    end

    include Enumerable
    
    def each(&block)
	    
    end b

    `include Enumerable
    
    def each(&block)
	    
    end^

    a include Enumerable
    
    def each(&block)
	    
    end


    #   -------------fdir--------------- 
    #  File.dirname(`^)                  



    File.dirname()

    File.dirname(_TYPED) b

    `File.dirname()^

    a File.dirname()


    #   -------------fet---------------   
    #  fetch(`name^) { |`key^| `cursor^ } 



    fetch(name) { |key|  }

    fetch(name_TYPED) { |key_TYPED|  } b

    `fetch(name) { |key|  }^

    a fetch(name) { |key|  }


    #   -------------file---------------                
    #  File.foreach('`filename^') { |`line^| `cursor^ } 



    File.foreach('filename') { |line|  }

    File.foreach('filename_TYPED') { |line_TYPED|  } b

    `File.foreach('filename') { |line|  }^

    a File.foreach('filename') { |line|  }


    #   -------------File--------------- 
    #  `file()^                          



    test.page.bare

    test.page.bare b

    `test.page.bare^

    a test.page.bare


    #   -------------fin--------------- 
    #  find { |`element^| `cursor^ }    



    find { |element|  }

    find { |element_TYPED|  } b

    `find { |element|  }^

    a find { |element|  }


    #   -------------fina--------------- 
    #  find_all { |`element^| `cursor^ } 



    find_all { |element|  }

    find_all { |element_TYPED|  } b

    `find_all { |element|  }^

    a find_all { |element|  }


    #   -------------fjoin--------------- 
    #  File.join(`dir^, `path^)           



    File.join(dir, path)

    File.join(dir_TYPED, path_TYPED) b

    `File.join(dir, path)^

    a File.join(dir, path)


    #   -------------fla---------------                    
    #  inject(Array.new) { |`arr^, `a^| `arr^.push(*`a^) } 



    inject(Array.new) { |arr, a| arr.push(*a) }

    inject(Array.new) { |arr_TYPED, a_TYPED| arr_TYPED.push(*a_TYPED) } b

    `inject(Array.new) { |arr, a| arr.push(*a) }^

    a inject(Array.new) { |arr, a| arr.push(*a) }


    #   -------------Forw--------------- 
    #  extend Forwardable                



    extend Forwardable

    extend Forwardable b

    `extend Forwardable^

    a extend Forwardable


    #   -------------fread--------------- 
    #  File.read(`filename^)              



    File.read(filename)

    File.read(filename_TYPED) b

    `File.read(filename)^

    a File.read(filename)


    #   -------------grep---------------        
    #  grep(/`pattern^/) { |`match^| `cursor^ } 



    grep(/pattern/) { |match|  }

    grep(/pattern_TYPED/) { |match_TYPED|  } b

    `grep(/pattern/) { |match|  }^

    a grep(/pattern/) { |match|  }


    #   -------------gsub---------------        
    #  gsub(/`pattern^/) { |`match^| `cursor^ } 



    gsub(/pattern/) { |match|  }

    gsub(/pattern_TYPED/) { |match_TYPED|  } b

    `gsub(/pattern/) { |match|  }^

    a gsub(/pattern/) { |match|  }


    #   -------------hash---------------                    
    #  Hash.new { |`hash^,`key^| `hash^[`key^] = `cursor^ } 



    Hash.new { |hash,key| hash[key] =  }

    Hash.new { |hash_TYPED,key_TYPED| hash_TYPED[key_TYPED] =  } b

    `Hash.new { |hash,key| hash[key] =  }^

    a Hash.new { |hash,key| hash[key] =  }


    #   -------------if--------------- 
    #  if `boolean exp^                
    #          `cursor^                
    #  end                             



    if boolean exp
	    
    end

    if booleanexp_TYPED
	    
    end b

    `if boolean exp
	    
    end^

    a if boolean exp
	    
    end


    #   -------------ife--------------- 
    #  if `boolean exp^                 
    #          `block^                  
    #  else                             
    #          `cursor^                 
    #  end                              



    if boolean exp
	    # block
    else
	    
    end

    if booleanexp_TYPED
	    block_TYPED
    else
	    
    end b

    `if boolean exp
	    # block
    else
	    
    end^

    a if boolean exp
	    # block
    else
	    
    end


    #   -------------ifei--------------- 
    #  if `boolean exp^`                 
    #          `block^                   
    #  ``elsif...`                       
    #  {{^elsif `comparison^             
    #          `block^                   
    #  ``elsif...`                       
    #  ^`}}^``else...`                   
    #  {{^else                           
    #          `cursor^                  
    #  `}}^end                           



    if boolean exp
	    # block
    elsif comparison
	    # block
    elsif comparison
	    # block
    elsif comparison
	    # block
    else
	    
    end

    if booleanexp_TYPED
	    block_TYPED
    elsif_TYPED
    else_TYPED
     end b

     `if boolean exp
	     # block
     elsif comparison
	     # block
     elsif comparison
	     # block
     elsif comparison
	     # block
     else
	     
     end^

     a if boolean exp
	     # block
     elsif comparison
	     # block
     elsif comparison
	     # block
     elsif comparison
	     # block
     else
	     
     end


    #   -------------inj---------------                        
    #  inject`(`arg`)^ { |`accumulator^, `element^| `cursor^ } 



    inject(arg) { |accumulator, element|  }

    inject(arg_TYPED) { |accumulator_TYPED, element_TYPED|  } b

    `inject(arg) { |accumulator, element|  }^

    a inject(arg) { |accumulator, element|  }


    #   -------------invoke_--------------- 
    #  `name^(`wrapped^)                    



name(WRAPPED_TEXT
WRAPPED_TEXT_line2)

name_TYPED(WRAPPED_TEXT
WRAPPED_TEXT_line2) b

`name(WRAPPED_TEXT
WRAPPED_TEXT_line2)^

a name(WRAPPED_TEXT
WRAPPED_TEXT_line2)


    #   -------------lam--------------- 
    #  lambda {` |`arg*`|^ `cursor^ }   



    lambda {  }

    lambda { |arg_TYPED, narg_TYPED, narg_TYPED|  } b

    `lambda {  }^

    a lambda {  }


    #   -------------loop--------------- 
    #  loop do                           
    #          `cursor^                  
    #  end                               



    loop do
	    
    end

    loop do
	    
    end b

    `loop do
	    
    end^

    a loop do
	    
    end


    #   -------------map--------------- 
    #  map { |`arg^| `cursor^ }         



    map { |arg|  }

    map { |arg_TYPED|  } b

    `map { |arg|  }^

    a map { |arg|  }


    #   -------------max---------------          
    #  max { |`element1^, `element2^| `cursor^ } 



    max { |element1, element2|  }

    max { |element1_TYPED, element2_TYPED|  } b

    `max { |element1, element2|  }^

    a max { |element1, element2|  }


    #   -------------Md---------------                                      
    #  File.open(`filename^, "wb") { |`file^| Marshal.dump(`obj^, `file^) } 



    File.open(filename, "wb") { |file| Marshal.dump(obj, file) }

    File.open(filename_TYPED, "wb") { |file_TYPED| Marshal.dump(obj_TYPED, file_TYPED) } b

    `File.open(filename, "wb") { |file| Marshal.dump(obj, file) }^

    a File.open(filename, "wb") { |file| Marshal.dump(obj, file) }


    #   -------------min---------------          
    #  min { |`element1^, `element2^| `cursor^ } 



    min { |element1, element2|  }

    min { |element1_TYPED, element2_TYPED|  } b

    `min { |element1, element2|  }^

    a min { |element1, element2|  }


    #   -------------Ml---------------                               
    #  File.open(`filename^, "rb") { |`file^| Marshal.load(`file^) } 



    File.open(filename, "rb") { |file| Marshal.load(file) }

    File.open(filename_TYPED, "rb") { |file_TYPED| Marshal.load(file_TYPED) } b

    `File.open(filename, "rb") { |file| Marshal.load(file) }^

    a File.open(filename, "rb") { |file| Marshal.load(file) }


    #   -------------mod--------------- 
    #  module `module name^             
    #          `cursor^                 
    #  end                              



    module ModuleName
	    
    end

    module ModulenameTYPED
	    
    end b

    `module ModuleName
	    
    end^

    a module ModuleName
	    
    end


    #   -------------modf--------------- 
    #  module `module name^              
    #          module_function           
    #                                    
    #          `cursor^                  
    #  end                               



    module ModuleName
	    module_function
    
	    
    end

    module ModulenameTYPED
	    module_function
    
	    
    end b

    `module ModuleName
	    module_function
    
	    
    end^

    a module ModuleName
	    module_function
    
	    
    end


    #   -------------module_--------------- 
    #  module `_^                           
    #          `wrapped^                    
    #  end                                  



module 
	WRAPPED_TEXT
	WRAPPED_TEXT_line2
end

    module TYPED
	    WRAPPED_TEXT
	    WRAPPED_TEXT_line2
    end b

    `module 
	    WRAPPED_TEXT
	    WRAPPED_TEXT_line2
    end^

    a module 
	    WRAPPED_TEXT
	    WRAPPED_TEXT_line2
    end


    #   -------------nam--------------- 
    #  namespace :`ns^ do               
    #          `cursor^                 
    #  end                              



    namespace :test.page do
	    
    end

    namespace :ns_TYPED do
	    
    end b

    `namespace :test.page do
	    
    end^

    a namespace :test.page do
	    
    end


    #   -------------new--------------- 
    #  `var^ = `Object^.new`(`arg*`)^   



    var = Object.new

    var_TYPED = ObjectTYPED.new(arg_TYPED, narg_TYPED, narg_TYPED) b

    `var = Object.new^

    a var = Object.new


    #   -------------open---------------                
    #  open(`filename^`, `mode...^) { |`io^| `cursor^ } 



    open(filename, 'wb') { |io|  }

    open(filename_TYPED, mode_TYPED) { |io_TYPED|  } b

    `open(filename, 'wb') { |io|  }^

    a open(filename, 'wb') { |io|  }


    #   -------------par---------------   
    #  partition { |`element^| `cursor^ } 



    partition { |element|  }

    partition { |element_TYPED|  } b

    `partition { |element|  }^

    a partition { |element|  }


    #   -------------pathf---------------          
    #  File.join(File.dirname(__FILE__), "`path^") 



    File.join(File.dirname(__FILE__), "../lib")

    File.join(File.dirname(__FILE__), "path_TYPED") b

    `File.join(File.dirname(__FILE__), "../lib")^

    a File.join(File.dirname(__FILE__), "../lib")


    #   -------------Pn--------------- 
    #  PStore.new(`filename^)          



    PStore.new(filename)

    PStore.new(filename_TYPED) b

    `PStore.new(filename)^

    a PStore.new(filename)


    #   -------------rej--------------- 
    #  reject { |`element^| `cursor^ }  



    reject { |element|  }

    reject { |element_TYPED|  } b

    `reject { |element|  }^

    a reject { |element|  }


    #   -------------rep---------------                       
    #  result.report("`name^: ") { TESTS.times { `cursor^ } } 



    result.report("name: ") { TESTS.times {  } }

    result.report("name_TYPED: ") { TESTS.times {  } } b

    `result.report("name: ") { TESTS.times {  } }^

    a result.report("name: ") { TESTS.times {  } }


    #   -------------req--------------- 
    #  require '`lib^'                  



    require 'lib'

    require 'lib_TYPED' b

    `require 'lib'^

    a require 'lib'


    #   -------------reqs---------------    
    #  %w[`lib*^].map { |lib| require lib } 



    %w[].map { |lib| require lib }
    

    %w[lib_TYPED lib_TYPED lib_TYPED].map { |lib| require lib }
     b

     `%w[].map { |lib| require lib }
     ^

     a %w[].map { |lib| require lib }
     


    #   -------------reve---------------     
    #  reverse_each { |`element^| `cursor^ } 



    reverse_each { |element|  }

    reverse_each { |element_TYPED|  } b

    `reverse_each { |element|  }^

    a reverse_each { |element|  }


    #   -------------ruby--------------- 
    #  #!/usr/bin/env ruby               
    #  _CMT_-*- encoding: `enc^ -*-      



    #!/usr/bin/env ruby
    # -*- encoding: utf-8 -*-

    #!/usr/bin/env ruby
    # -*- encoding: enc_TYPED -*- b

    `#!/usr/bin/env ruby
    # -*- encoding: utf-8 -*-^

    a #!/usr/bin/env ruby
    # -*- encoding: utf-8 -*-


    #   -------------sb--------------- 
    #  #!/usr/bin/env ruby             
    #  _CMT_-*- encoding: `enc^ -*-    



    #!/usr/bin/env ruby
    # -*- encoding: utf-8 -*-

    #!/usr/bin/env ruby
    # -*- encoding: enc_TYPED -*- b

    `#!/usr/bin/env ruby
    # -*- encoding: utf-8 -*-^

    a #!/usr/bin/env ruby
    # -*- encoding: utf-8 -*-


    #   -------------scan---------------        
    #  scan(/`pattern^/) { |`match^| `cursor^ } 



    scan(/pattern/) { |match|  }

    scan(/pattern_TYPED/) { |match_TYPED|  } b

    `scan(/pattern/) { |match|  }^

    a scan(/pattern/) { |match|  }


    #   -------------sel--------------- 
    #  select { |`element^| `cursor^ }  



    select { |element|  }

    select { |element_TYPED|  } b

    `select { |element|  }^

    a select { |element|  }


    #   -------------shebang--------------- 
    #  #!/usr/bin/env ruby                  
    #  _CMT_-*- encoding: `enc^ -*-         



    #!/usr/bin/env ruby
    # -*- encoding: utf-8 -*-

    #!/usr/bin/env ruby
    # -*- encoding: enc_TYPED -*- b

    `#!/usr/bin/env ruby
    # -*- encoding: utf-8 -*-^

    a #!/usr/bin/env ruby
    # -*- encoding: utf-8 -*-


    #   -------------sinc--------------- 
    #  class << self; self; end          



    class << self; self; end

    class << self; self; end b

    `class << self; self; end^

    a class << self; self; end


    #   -------------sor---------------                            
    #  sort { |`element1^, `element2^| `element1^ <=> `element2^ } 



    sort { |element1, element2| element1 <=> element2 }

    sort { |element1_TYPED, element2_TYPED| element1_TYPED <=> element2_TYPED } b

    `sort { |element1, element2| element1 <=> element2 }^

    a sort { |element1, element2| element1 <=> element2 }


    #   -------------sorb--------------- 
    #  sort_by {` |`arg`|^ `cursor^ }    



    sort_by { |arg|  }

    sort_by { |arg_TYPED|  } b

    `sort_by { |arg|  }^

    a sort_by { |arg|  }


    #   -------------ste---------------          
    #  step(`count^`, `step^) { |`i^| `cursor^ } 



    step(count, step) { |i|  }

    step(count_TYPED, step_TYPED) { |i_TYPED|  } b

    `step(count, step) { |i|  }^

    a step(count, step) { |i|  }


    #   -------------sub---------------        
    #  sub(/`pattern^/) { |`match^| `cursor^ } 



    sub(/pattern/) { |match|  }

    sub(/pattern_TYPED/) { |match_TYPED|  } b

    `sub(/pattern/) { |match|  }^

    a sub(/pattern/) { |match|  }


    #   -------------subcl--------------- 
    #  class `ClassName^ < `Parent^       
    #          `cursor^                   
    #  end                                



    class ClassName < Parent
	    
    end

    class ClassNameTYPED < ParentTYPED
	    
    end b

    `class ClassName < Parent
	    
    end^

    a class ClassName < Parent
	    
    end


    #   -------------tas---------------    
    #  desc "`task description^"           
    #  task :`task name^` => [:`dep*`]^ do 
    #          `cursor^                    
    #  end                                 



    desc "task description"
    task :task_name do
	    
    end

    desc "taskdescription_TYPED"
    task :taskname_TYPED => [:dep_TYPED, :ndep_TYPED, :ndep_TYPED] do
	    
    end b

    `desc "task description"
    task :task_name do
	    
    end^

    a desc "task description"
    task :task_name do
	    
    end


    #   -------------tc---------------              
    #  require "test/unit"                          
    #  require "`module^"                           
    #                                               
    #  class Test`ClassName^ < Test::Unit::TestCase 
    #          `deft^`                              
    #                                               
    #          `deft...`{{^                         
    #                                               
    #          `deft^`                              
    #                                               
    #          `deft...`^`}}^                       
    #  end                                          



    require "test/unit"
    require "module"
    
    class TestModule < Test::Unit::TestCase
	    def test_name
		    
	    end
    
	    def test_name
		    
	    end
    
	    def test_name
		    
	    end
    
	    def test_name
		    
	    end
    end

    require "test/unit"
    require "module_TYPED"
    
    class TestClassNameTYPED < Test::Unit::TestCase
	    def test_name_TYPED
		    deft_TYPED
	    end
	
    	    deft_TYPED
    end b

    `require "test/unit"
    require "module"
    
    class TestModule < Test::Unit::TestCase
	    def test_name
		    
	    end
    
	    def test_name
		    
	    end
    
	    def test_name
		    
	    end
    
	    def test_name
		    
	    end
    end^

    a require "test/unit"
    require "module"
    
    class TestModule < Test::Unit::TestCase
	    def test_name
		    
	    end
    
	    def test_name
		    
	    end
    
	    def test_name
		    
	    end
    
	    def test_name
		    
	    end
    end


    #   -------------tif---------------                 
    #  (`boolean exp^) ? `exp if true^ : `exp if false^ 



    (boolean exp) ? exp if true : exp if false

    (booleanexp_TYPED) ? expiftrue_TYPED : exp if false b

    `(boolean exp) ? exp if true : exp if false^

    a (boolean exp) ? exp if true : exp if false


    #   -------------tim--------------- 
    #  times {` |`i`|^ `cursor^ }       



    times { |i|  }

    times { |i_TYPED|  } b

    `times { |i|  }^

    a times { |i|  }


    #   -------------tra--------------- 
    #  transaction(`true^) { `cursor^ } 



    transaction(true) {  }

    transaction(true_TYPED) {  } b

    `transaction(true) {  }^

    a transaction(true) {  }


    #   -------------unif--------------- 
    #  ARGF.each_line do |`line^|        
    #          `cursor^                  
    #  end                               



    ARGF.each_line do |line|
	    
    end

    ARGF.each_line do |line_TYPED|
	    
    end b

    `ARGF.each_line do |line|
	    
    end^

    a ARGF.each_line do |line|
	    
    end


    #   -------------unless--------------- 
    #  unless `boolean cond^               
    #          `cursor^                    
    #  end                                 



    unless boolean cond
	    
    end

    unless booleancond_TYPED
	    
    end b

    `unless boolean cond
	    
    end^

    a unless boolean cond
	    
    end


    #   -------------until--------------- 
    #  until `boolean cond^               
    #          `cursor^                   
    #  end                                



    until boolean cond
	    
    end

    until booleancond_TYPED
	    
    end b

    `until boolean cond
	    
    end^

    a until boolean cond
	    
    end


    #   -------------upt---------------  
    #  upto(`ubound^) { |`i^| `cursor^ } 



    upto(ubound) { |i|  }

    upto(ubound_TYPED) { |i_TYPED|  } b

    `upto(ubound) { |i|  }^

    a upto(ubound) { |i|  }


    #   -------------usai---------------              
    #  if ARGV`^                                      
    #          abort "Usage: #{$PROGRAM_NAME} `args^" 
    #  end                                            



    if ARGV
	    abort "Usage: #{$PROGRAM_NAME} [options]"
    end

    if ARGV_TYPED
	    abort "Usage: #{$PROGRAM_NAME} args_TYPED"
    end b

    `if ARGV
	    abort "Usage: #{$PROGRAM_NAME} [options]"
    end^

    a if ARGV
	    abort "Usage: #{$PROGRAM_NAME} [options]"
    end


    #   -------------usau---------------              
    #  unless ARGV`^                                  
    #          abort "Usage: #{$PROGRAM_NAME} `args^" 
    #  end                                            



    unless ARGV
	    abort "Usage: #{$PROGRAM_NAME} [options]"
    end

    unless ARGV_TYPED
	    abort "Usage: #{$PROGRAM_NAME} args_TYPED"
    end b

    `unless ARGV
	    abort "Usage: #{$PROGRAM_NAME} [options]"
    end^

    a unless ARGV
	    abort "Usage: #{$PROGRAM_NAME} [options]"
    end


    #   -------------while--------------- 
    #  while `boolean cond^               
    #          `cursor^                   
    #  end                                



    while boolean cond
	    
    end

    while booleancond_TYPED
	    
    end b

    `while boolean cond
	    
    end^

    a while boolean cond
	    
    end


    #   -------------wid---------------             
    #  with_index { |`element^, `index^| `cursor^ } 



    with_index { |element, index|  }

    with_index { |element_TYPED, index_TYPED|  } b

    `with_index { |element, index|  }^

    a with_index { |element, index|  }


    #   -------------xml---------------           
    #  REXML::Document.new(File.read(`filename^)) 



    REXML::Document.new(File.read(filename))

    REXML::Document.new(File.read(filename_TYPED)) b

    `REXML::Document.new(File.read(filename))^

    a REXML::Document.new(File.read(filename))


    #   -------------Yd---------------                                         
    #  File.open("`filename^.yaml", "wb") { |`file^| YAML.dump(`obj^,`file^) } 



    File.open("filename.yaml", "wb") { |file| YAML.dump(obj,file) }

    File.open("filename_TYPED.yaml", "wb") { |file_TYPED| YAML.dump(obj_TYPED,file_TYPED) } b

    `File.open("filename.yaml", "wb") { |file| YAML.dump(obj,file) }^

    a File.open("filename.yaml", "wb") { |file| YAML.dump(obj,file) }


    #   -------------Yl---------------                             
    #  File.open("`filename^.yaml") { |`file^| YAML.load(`file^) } 



    File.open("filename.yaml") { |file| YAML.load(file) }

    File.open("filename_TYPED.yaml") { |file_TYPED| YAML.load(file_TYPED) } b

    `File.open("filename.yaml") { |file| YAML.load(file) }^

    a File.open("filename.yaml") { |file| YAML.load(file) }


    #   -------------zip--------------- 
    #  zip(`enum^) { |`row^| `cursor^ } 



    zip(enum) { |row|  }

    zip(enum_TYPED) { |row_TYPED|  } b

    `zip(enum) { |row|  }^

    a zip(enum) { |row|  }


    #   -------------{_--------------- 
    #  {`w^}                           



{WRAPPED_TEXT
WRAPPED_TEXT_line2}

{WRAPPED_TEXT
WRAPPED_TEXT_line2} b

`{WRAPPED_TEXT
WRAPPED_TEXT_line2}^

a {WRAPPED_TEXT
WRAPPED_TEXT_line2}