function foo() {
  function foo($a) {
	public function foo()
 	 public function x
public function foo() {
private function foo()
protected function foo()
public static function foo()
static public function foo()
abstract public function foo();
final function foo()
abstract function foo()
public public function x
public static final abstract private protected function x
static static static static static static static static function x
public  static		function x
a b c d e f g function x
readonly function x
var function x
publicx function x
public static
function &foo()
function
function 
function(
functionx foo()
xfunction foo()
publicfunction x
public functionx
public function
$x = function() {
FUNCTION foo()
Function foo()
class Foo {
class Foo extends Bar
class
classFoo
Class Foo
abstract class Foo
final class Foo
final  class x
final	class x
final classx
finalclass x
final final class x
abstract abstract class x
final abstract class Foo
public class Foo
static class Foo
readonly class Foo
public static  class x
interface Foo
interface
interfacex
trait Foo
traitx
enum Foo
enum(
enumx
namespace Foo;
fn($x) => 1
public fn foo()
public $foo;
const X = 1;
<?php
// function foo
# function foo
* function foo
function x
publicfunction x
finalclass x
public static function été
function

 trait=> 1functions	foo	traitfunctions	
function f.oo() {
 	final class Foo
 	trait T
=> 1
abstract  class	Foo
enum- E: string=> 1
static public abstract function y();
enum E: string
  static public abstract function y();
 functions}	étÃ
 interface<?php__construct&foo=> 1static
function <?php	, 	Functionextends Bas\efoo
 interface XI<?php
final class Foo=> 1
private final function &x() {
private final function &x()
 final class Foo
final class oo
public static function foo($x)
impleme
nts I
  private final function &x()
 	classvar($a, $b = 1) B
traitfoo
trait  <?phpBar 	
interface I
	enum E:* s
	private final function &x()
public static function foo($x)
trait 
trait T
  final class Foo
 trait
été
extends Base	extends Base 	//
trait >T
 private final function &x()
  trait T
functionsf@oonamespacefoo// Bar
static public abstract function y();(): int
  abstract  class	Foo=> 1
 enum E: string	($a, $b = 1)8
enum E: \str@ing
	interface I
<?php
	public static function foo($x)
trait T(): int
 	static public abstract function y(); // c
 public static function foo($x)
private final function &x()  
public static function foo(X$x)
enum : éstring
  class 	//
 	enum E: string
static  	public abstract function y();extends Base
private final function *&x()
enum E: strinæg
  function
interface &foo
  trait 	Bar 	("
function¼ foo() {
 interface I
enum	 E: string
 	abstract  class	Foo
// c
enum E: string<?php
enum E-: string
function foo(^) {
functions  
	function foo(){ Ximplemen@ts I
 enum E: str
enum E: string 	implements I
private final function &x(
 	abstract  class	Foo
	interface I
 enum
abstract  
final class. Foo
functionsprotected__constructfinal
traitX T  => 1
function foo () {
function foo() ž{
final class Fo	o
 public static function foo($x)  extends Base
 private final function &x()
implements I
 	function foo() {
classété	_	enum 
enum E: string

$x =  Bar implements I 	=> 1 
static  &foo
é
#  

static public abstract function y();
($a, $b = 1)
implements I
klassf[oo$impleme
nts I
ééfnklass~
<?php=> 1Function(): int	abstractextend0s Base
 INteRfAce I
fnclass
Bar	(): int Barété$x =protected
$x =
 =	function
&foo éOté_x( 	): int^`¶	

public static function foo($x)

 	; 	_x	
Z{
// c
foo
__construct  => 1
INteRFAC}E 
 ;// cFInAL //  	 ($A, $b = 1) C

var/_/  final	interface 	
 	$

final class Foo
(): intinterface * klass 	]	
	stat[ic public abstract function y();

interface I

été
_
;  $x =
__construct(Bar	Function
	=>  	1	<?php  
namespace&foo;function<  
 const _x	// c
publicstatic function foo($x)Ð
($A, $b = 1)FuNCTION  
 __construct  __constructfunctions  __construct	=&foo
&foo
__construct
private	klass
fnenum,  _%x
 	fntraitpr9otected  
enum E: string// c
, 	été__constr
	?	extends Base<?phpnamespace($a, $b = 1)__construct
% Fn
function foo() {:  
static publc abstract function y();
TrAit t(): InT
//
 	fn$x=  fnFunction?	
	constpublic
P
final class Foo
ã@
  pr¯ivate  

été// c
fn ;	

fN
$
FUnCTioNS  BAR($A, $b = 1)&fOO 
=> 1 	foo{($a, $b = 1) 
    Bar
interface I
__construct 	protected  namespace  
	extends Base étéBar 	fn// c$x =  
 prOt
functÏion  =abstract __co
nstruct => 1 	<?php

var 
klass 	privateétéabstractprivateéclass
function foo() {
 #	prÿivate functionclassfoo
$x = 	é;	var
+	;Bar~
éTé% TRAIT
pUbLiC; 
 prIVatE FINAL functioN &X()	(): iNT
Barreadonly trait&foo
implements I  

trŽa.it T
<?phpfunctionfunction
 Bar  été	_
static  namespace
__construct 	// trait
function  class
public static function foo($x)
// cétéété	_x<?php_x
__construcüt 	fnfn