def foo
  def foo(a)
	def self.foo
class Foo
class Foo < Bar
module Foo
  module Foo::Bar
defx foo
xdef foo
def
def 
deffoo
class
classFoo
module
moduleFoo
Class Foo
Module Foo
DEF foo
def  foo  # c
private def foo
do |x|
end
def	foo
class	Foo
module	Foo
# def foo
x = 1
def foo; end
class << self
def foo
def foo

def foo
deffoo
def
foo
moduleX
def(
class(
module(
def=
 	 def x
attr_accessor :foo
define_method(:x)
def été

  
def sel;f.foo(x)	:sym
	class << &self
	def	ar# comment
	def	bar
  def self.foo(x)
 		def	bar
module Foo	self.foo
def >f  oo# c<omment
class Foo < |Bar
  class Foo < Bar	self.foo
	module Foo
class << s0elf
 	def self.foo(xx)
def self.foo(x)
def sElF.FOo(x)
def self.foo(x) ; end
def self
 	def	bar	selfé.foo
class Foo < éBar= 71
class << self(a, b 
class Fo0o < Bar
def self.foo(x)|x|
def sel.foo
 def foo
class <<
 def self.foo  (x)
def self.foo
	def	b  ar
class << SELf  (A, B = 1)
class Foo < Bar; end
class Foo < Bar |x|
def self.foo($x)
class -<< self
def s0elf.foo(x)  self.foo
class Foo < Ba
  	def	bar
	def	bar
:sym
	def	bar= 1
 def   self.foo(x)< Base
def foo:sym
def self.foo(x) # comment
 	def se"lf.foo(x)
	def	bar@
class << se.lf
  def 	modules
  class Fo&o < Bar	; end
class F (oo < Bar= 1
 	module 	
	def	bar= 1
  class 	_x 	("
	def	bar 	; end
 module Foo
module	klassself.foo
	def	bar|x|
 class Foo < Bar|x|
  def sel
 	module ,F
class << self 	self.foo
 	def self.foo(x)
  def self.foo(x)(a, b = 1)é
 	module Foo
class Foo < Bar# comment
def	 self.foo(x)
module Fo0o |x|
 	class Foo < Bar
module 	xdef; end
	class << elf
def self.foo(x)	< XBase
class Foo < Bar # commenét
 def 
def self.foo(Zx)
class << elfô# comment
	class Fo < Bxar\
def foo = 1
	class Foo < Bar
	def self.foo(x)self.foo
 	class Foo < Bar	< Base
class << self  < Base
class << elf
def elf.foox)
def self.foo(*x)
def selfX.foo(x)
# comment
module Foo	.self.foå
class Foo X< Bar  # comment
 	class Foo < Bar
	def	bar# comment
def f`o-o
class << s

Module  initialize self.foo 	# comment 
KlASÚs  éT©
	# comment_x  |x|defx
  foo:sym
defx< Base
_xxdef[Bar$self.f
oo
_x 	bar!~
#com0ment
	^clas Foo < Bar
  # écomme(nt
Foo::ar# foo
  self.foo:sym
 kla  ss	
modue F
	initialize	end Bar  EF|x|ar! 
	_^é`	:
 	do
self.foo  do_x foo
 Barfoo
Foo
mo
def

module Fošo
Ådef foo
Pdef self.foXo(x)
#  
 fooDEFmodulelass Bar
 ^ private	
	*self.cas
 ; end 
	clss Foo < Bar
< Baseclass  xdef* 	]	
MODUlE FOO
é
=X 1_x 	do Bardo
; endFoo::Bar
@été  
cla  ss << self
|x|

)	de	bar
foo # comment  Foo::Bar
 	self.foo_x< Base<<
'Xclass
 :0
|x|;moduleinitialize	
  = 1class:
(a, b ,= 1)klas:sxdef 	?  
|x|	cx-lass:symfoo?  
# commentDEF|x|
 ; $endBar 
Foo::Bar#	klassbar! _x
(a, b = 1)
	célass uFoo < 	 Bar
 end:sym  |x|defxétéfoo? 	
  defx.
module|x|bar!=  	1ý 
été_x# comment
 = 1été 	<_x&}
 	endklass  klasscl;a-ss 	# comment
module  Foo
, 	 	modules
_
	~
Module FoO:SyM
	self. 	DEF # comment
\  
	
EnD
/  initialize(a, b = 1)foo initialize  bar! 
= 1
 modules	
clss Foo < Bar
$class	|x|
CLAs foO <
(a, b = 1)	self.fooinitializeété 	
 foo
(a, b = 1)	SelF. bar!XDEF	
< Baése  dofoo?self. Foo::Bar # comment 	
 foo
klass xdef:sym
class
foo bar!self.fo#o
	; enddef klass<< 	Barmodule
self.DEFiniétialize?	defx
+	=\ 1_x-/
foo?DEF Module:sym 	s elf.
private  private  foo?foo?
 	< Base~foo
dodef  _  
sELf.Foo  SeLF9. été  	BAR!
/self.foo	bar!  moduleprivate