All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.jopendocument.dom.oofficeDTDs.OpenDocument-v1.2-schema.rng Maven / Gradle / Ivy

Go to download

jOpenDocument is a free library for developers looking to use Open Document files without OpenOffice.org.

The newest version!



	
		
			
				
			
		
	
	
		
			
			
			
			
			
		
	
	
		
			
			
			
			
			
			
			
			
			
			
		
	
	
		
			
			
			
			
			
		
	
	
		
			
			
			
			
			
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
			
				1.2
			
			
				
					
						
							
						
					
				
			
		
	
	
		
			
		
	
	
		
			
				
			
		
	
	
		
			
		
	
	
		
			
		
	
	
		
			
				
				
				
				
			
			
				
				
				
				
			
			
				
				
				
				
			
			
				
				
				
				
			
			
				
				
				
				
			
			
				
				
				
				
			
			
		
	
	
		
		
		
		
	
	
		
			
				
			
			
				
				
					
						
					
				
			
		
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
	
	
		
		
	
	
		
			
		
	
	
		
	
	
		
	
	
		
		
		
	
	
		
			
		
	
	
		
		
	
	
		
			
		
		
		
	
	
		
			
		
		
			
		
		
			
		
	
	
		
			
		
	
	
		
	
	
		
			
		
		
			
		
		
			
		
		
			
		
		
			
		
	
	
		
	
	
		
		
	
	
		
	
	
		
	
	
		
	
	
		
	
	
		
	
	
		
	
	
		
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
				
				
				
			
		
	
	
		
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
					boolean
					short
					int
					long
					double
					string
					datetime
					base64Binary
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
		
	
	
		
			
			
		
	
	
		
			
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
		
	
	
		
			
				
					
				
				
					
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
		
	
	
		
			
				
					
				
			
		
	
	
		
			
				
					
					
						
					
					
						
					
					
						
					
					
						
					
					
						
					
					
						
					
					
						
					
					
						
					
					
						
					
					
						
					
					
						
					
					
						
					
					
						
					
					
						
					
					
						
					
					
						
					
				
			
		
	
	
		
			
				
					
					
						
					
				
			
		
	
	
		
			
				
					
						
					
					
						
					
					
						
					
				
			
		
	
	
		
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
			
				
			
			
				
			
			
			
				
			
			
				
					simple
				
				
					
				
				
					
						onRequest
					
				
				
					
						
					
				
				
					
						
					
				
			
			
				
					
						simple
					
					
						
					
					
						
							replace
						
					
					
						
							onLoad
						
					
				
				
					
						
					
				
			
			
				
					
						
					
				
				
					
						
							new
							replace
						
					
				
			
			
				
			
			
				
			
			
				
			
			
				
					
						
					
				
				
					
						
					
				
				
					
						
					
				
				
					
						
					
				
				
					
						
					
				
				
					
						
					
				
				
					
						
					
				
				
					
						
					
				
				
					
						
					
				
				
					
						
					
				
				
					
						
					
				
				
					
						
					
				
				
					
						
					
				
				
					
						
					
				
				
					
						
					
				
			
			
				
					
				
				
					
						
							float
						
						
					
					
						
							date
						
						
					
					
						
							time
						
						
					
					
						
							boolean
						
						
					
					
						
							string
						
						
					
					
				
			
		
	
	
		
			
		
	
	
		
			
		
	
	
		
			
			
			
				
			
			
				
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
					
						
							
						
					
				
			
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
		
	
	
		
			
		
	
	
		
			
			
				
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
			
		
	
	
		
			
			
		
	
	
		
			
		
		
			
				
				
				
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
			
		
	
	
		
			
			
		
	
	
		
			
		
	
	
		
			
			
				
			
			
				
				
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					
				
				
					
				
				
					
				
			
			
				
			
		
	
	
		
			
			
				
				
				
			
			
				
			
		
	
	
		
			
			
				
					
						true
						none
					
				
				
					
						condition
					
					
						
					
				
				
			
		
	
	
		
			
				
					
				
			
			
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
			
		
	
	
		
			
		
	
	
		
			
				
					simple
				
				
					
				
				
					
						embed
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
	
	
		
			
				
				
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
		
	
	
		
			
			
				
					
				
			
		
	
	
		
			
				
			
			
				
				
					
				
			
			
				
			
		
	
	
		
			
				
			
			
				
			
			
				
			
		
	
	
		
			
		
	
	
		
			
		
	
	
		
			
				
					
				
			
		
		
			
				
					
				
			
		
		
			
				
					
				
			
		
		
			
				
					
				
			
		
		
			
		
	
	
		
			
			
		
	
	
		
			
			
				
					
						
					
				
			
			
				
			
			
				
			
			
			
				
					
						
					
				
				
					
						
					
				
				
					
				
			
			
				
				
					
				
			
			
				
				
				
			
			
				
					
				
			
			
				
					
						
					
				
				
					
						
					
				
			
			
				
				
					
						
					
				
				
					
						
							
						
					
					
				
				
					
						
					
				
			
			
				
					
						
					
				
				
					
						
					
				
				
					
						
							
						
					
					
				
			
			
				
				
			
			
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
			
			
				
					
					
					
					
					
				
				
			
			
				
					
					
					
				
				
			
			
				
					
					
					
					
					
				
				
			
			
				
					
					
					
				
				
			
			
				
					
					
					
				
				
			
			
				
					
					
					
					
				
				
			
			
				
					
					
						
					
					
					
				
				
			
			
				
				
			
			
				
				
			
			
				
					
					
					
						
							
						
					
				
				
			
			
				
					
					
					
						
							
						
					
				
				
			
			
				
				
			
			
				
					
					
						
					
					
					
						
							
						
					
					
						
							
						
					
					
						
							
						
					
					
						
							
						
					
					
						
							
						
					
				
				
			
			
				
					
					
					
						
							
						
					
				
				
			
			
				
					
					
					
						
							
						
					
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
					
					
					
						
							
						
					
				
				
			
			
				
					
					
					
						
							
						
					
				
				
			
			
				
					
					
					
						
							
						
					
				
				
			
			
				
				
			
			
				
					text:page-count
					text:paragraph-count
					text:word-count
					text:character-count
					text:table-count
					text:image-count
					text:object-count
				
				
				
			
			
				
				
			
			
				
			
			
				
			
			
				
					
					
					
						
							
						
					
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
					text:reference-ref
					text:bookmark-ref
				
				
					
					
				
			
			
				
					
					
				
			
			
				
					
					
				
			
			
				
					
						
							
								simple
							
							
								
							
						
						
					
					
						
							
						
					
				
			
			
				
					
						
					
				
				
					
				
				
			
			
				
				
			
			
				
					
				
				
			
			
				
					
						value
						unit
						gap
					
				
				
			
			
				
					
					
					
				
				
			
			
				
				
					
				
			
			
				
			
			
				
			
			
				
					
				
				
			
			
				
				
				
			
			
				
			
			
				
					
				
				
				
			
			
				
				
			
			
				
			
			
				
					
				
				
			
			
				
					
				
				
					
						
							text:identifier
							text:address
							text:annote
							text:author
							text:booktitle
							text:chapter
							text:edition
							text:editor
							text:howpublished
							text:institution
							text:journal
							text:month
							text:note
							text:number
							text:organizations
							text:pages
							text:publisher
							text:school
							text:series
							text:title
							text:report-type
							text:volume
							text:year
							text:url
							text:custom1
							text:custom2
							text:custom3
							text:custom4
							text:custom5
							text:isbn
							text:issn
						
						
					
				
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
				
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				simple
			
			
				
			
			
				
					onRequest
				
			
			
				
					
				
			
			
				
					
						new
						replace
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
			
			
				
			
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
			
		
	
	
		
			
				
			
			
				
			
			
				
			
		
	
	
		
			
		
	
	
		
			
				footnote
				endnote
			
		
	
	
		
			
				
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
				
			
			
				
					
				
			
			
				
					
						previous
						current
						next
					
				
			
		
	
	
		
			
				
					previous
					next
				
			
			
				
					
				
			
		
	
	
		
			
				
					name
					number
					number-and-name
					plain-number-and-name
					plain-number
				
			
			
				
			
		
	
	
		
			
				
					
						full
						path
						name
						name-and-extension
					
				
			
			
		
	
	
		
			
				
					full
					path
					name
					name-and-extension
					area
					title
				
			
		
	
	
		
			
			
		
	
	
		
			
			
				
			
			
		
	
	
		
			
		
	
	
		
			
			
				
			
			
				
					
				
			
		
	
	
		
			
				
			
		
	
	
		
		
	
	
		
			
				
					
				
			
			
		
	
	
		
			
				
			
			
				
					
						table
						query
						command
					
				
			
		
	
	
		
			
			
			
				
			
		
	
	
		
			
			
				
					
				
			
		
	
	
		
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
	
	
		
			
				
					text
					table
					text-box
					image
					object
				
			
			
		
	
	
		
			
				
			
			
				
			
			
				
			
			
				
					
				
			
		
	
	
		
			
				
			
			
				
			
			
				
					
				
			
		
	
	
		
			
			
				
					
				
			
		
	
	
		
			
				
					
					number-no-superior
					number-all-superior
					number
				
			
		
	
	
		
			
				
					
						
					
				
			
			
		
	
	
		
			
				
					
					category-and-value
					caption
					value
				
			
		
	
	
		
			page
			chapter
			direction
			text
		
	
	
		
			
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
		
	
	
		
			
				
					float
				
				
					
				
			
			
				
					percentage
				
				
					
				
			
			
				
					currency
				
				
					
				
				
					
						
					
				
			
			
				
					date
				
				
					
				
			
			
				
					time
				
				
					
				
			
			
				
					boolean
				
				
					
				
			
			
				
					string
				
				
					
						
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
		
	
	
		
			
				
			
		
	
	
		
			
				
					value
					none
				
			
		
	
	
		
			
				
					value
					formula
					none
				
			
		
	
	
		
			
				
					value
					formula
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
		
	
	
		
		
	
	
		
			
				
			
		
	
	
		
			
		
	
	
		
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			article
			book
			booklet
			conference
			custom1
			custom2
			custom3
			custom4
			custom5
			email
			inbook
			incollection
			inproceedings
			journal
			manual
			mastersthesis
			misc
			phdthesis
			proceedings
			techreport
			unpublished
			www
		
	
	
		
			
				
			
		
	
	
		
			
			
		
	
	
		
			
			
				
			
		
	
	
		
			
			
			
		
	
	
		
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						document
						chapter
					
				
			
			
				
					
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
			
			
			
			
			
			
		
	
	
		
			
				
			
			
				
			
		
	
	
		
			
			
			
		
	
	
		
			
			
				
			
			
				
			
		
	
	
		
			
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						text
						category-and-value
						caption
					
				
			
		
	
	
		
			
				
					document
					chapter
				
			
		
	
	
		
			
				
			
		
	
	
		
			
		
	
	
		
		
			
				
				
				
				
				
			
		
	
	
		
			
		
	
	
		
			
			
			
		
	
	
		
			
			
				
			
			
				
			
		
	
	
		
			
		
	
	
		
			
			
			
		
	
	
		
			
			
				
			
			
				
			
		
	
	
		
			
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
			
			
		
	
	
		
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
			
		
	
	
		
			
			
				
					
					
					
					
					
				
			
		
	
	
		
			
				
			
			
				
			
		
	
	
		
			
			
			
		
	
	
		
			
			
				
			
			
				
			
		
	
	
		
			
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				simple
			
			
				
			
		
	
	
		
			
			
				
					
					
					
					
					
				
			
		
	
	
		
			
				
					1
					2
					3
					separator
				
			
			
				
			
		
	
	
		
			
			
			
		
	
	
		
			
				
			
			
				
			
		
	
	
		
			
			
				
					
					
					
				
			
		
	
	
		
			
				
			
			
				
			
		
	
	
		
			
				
			
			
				
			
		
	
	
		
			
				
			
			
		
	
	
		
			
				
					
				
			
			
		
	
	
		
			
				
					
				
			
			
		
	
	
		
			
				
					
						name
						number
						number-and-name
						plain-number
						plain-number-and-name
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
				
			
		
	
	
		
			
				
					
				
			
		
	
	
		
			
				
					
				
			
			
		
	
	
		
			
		
	
	
		
			
				
					
				
			
			
				
					address
					annote
					author
					bibliography-type
					booktitle
					chapter
					custom1
					custom2
					custom3
					custom4
					custom5
					edition
					editor
					howpublished
					identifier
					institution
					isbn
					issn
					journal
					month
					note
					number
					organizations
					pages
					publisher
					report-type
					school
					series
					title
					url
					volume
					year
				
			
		
	
	
		
			
				
					
				
			
			
		
	
	
		
			
				
					
				
			
			
				
					right
				
				
					
						left
					
					
						
					
				
			
		
	
	
		
			
				
					
				
			
		
	
	
		
			
				
					
				
			
		
	
	
		
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
			
			
				
			
		
	
	
		
			
				
				
			
		
	
	
		
			
				
				
					
					
						
					
				
			
			
				
				
					
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
				
			
		
	
	
		
			
				
				
					
					
						
					
				
			
			
				
				
					
				
			
		
	
	
		
			
			
				
					
				
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
		
	
	
		
			
			
				
					
					
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
			
		
	
	
		
			visible
			collapse
			filter
		
	
	
		
			
			
			
		
	
	
		
			
			
		
	
	
		
			
		
		
			
		
		
			
		
		
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
			
			
				
					
				
			
			
				
					
				
			
			
				
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
		
	
	
		
			
				
					
				
				
			
		
	
	
		
			
				
					
				
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
		
	
	
		
			($?([^\. ']+|'([^']|'')+'))?\.$?[A-Z]+$?[0-9]+
		
	
	
		
			
				($?([^\. ']+|'([^']|'')+'))?\.$?[A-Z]+$?[0-9]+(:($?([^\. ']+|'([^']|'')+'))?\.$?[A-Z]+$?[0-9]+)?
			
			
				($?([^\. ']+|'([^']|'')+'))?\.$?[0-9]+:($?([^\. ']+|'([^']|'')+'))?\.$?[0-9]+
			
			
				($?([^\. ']+|'([^']|'')+'))?\.$?[A-Z]+:($?([^\. ']+|'([^']|'')+'))?\.$?[A-Z]+
			
		
	
	
		
		Value is a space separated list of "cellRangeAddress" patterns
	
	
		
			
			
			
		
	
	
		
			
				
					
						copy-all
						copy-results-only
					
				
			
			
				
					
				
			
		
	
	
		
			
				simple
			
			
				
			
			
				
					onRequest
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
			
		
	
	
		
			
				
			
			
				
			
			
				
			
		
	
	
		
			
				
			
			
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					trace-dependents
					remove-dependents
					trace-precedents
					remove-precedents
					trace-errors
				
			
			
				
			
		
	
	
		
			
				
					
				
				
					
				
			
			
		
	
	
		
			
				
					
				
			
			
				
					from-another-table
					to-another-table
					from-same-table
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
				
			
		
		
			
				
			
		
		
			
				
			
		
	
	
		
			
			
				
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					date
				
			
			
				
					
				
			
			
		
	
	
		
			
				
					
						enable
						disable
					
				
			
			
				
					
				
			
			
				
					
				
			
			
		
	
	
		
			
				
			
		
	
	
		
			
			
				
			
			
				
					
					
						
						
					
				
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						none
						unsorted
						sort-ascending
					
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
						stop
						warning
						information
					
				
			
			
				
			
		
	
	
		
			
				
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
			
			
				
					column
					row
				
			
		
	
	
		
			
				
					
					
				
			
		
	
	
		
			
			
		
	
	
		
			
		
		
			
		
		
			
				
			
		
		
			
				
					none
					
						
							
								print-range
								filter
								repeat-row
								repeat-column
							
						
					
				
			
		
	
	
		
			
			
		
	
	
		
			
		
		
			
		
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
				
					
					
					
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						column
						row
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						alpha-numeric
						integer
						double
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
					
						text
						number
						automatic
						
					
				
			
			
				
					
						ascending
						descending
					
				
			
		
	
	
		
			
			
				
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					
						text
						number
						automatic
						
					
				
			
			
				
					
						ascending
						descending
					
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
					average
					count
					countnums
					max
					min
					product
					stdev
					stdevp
					sum
					var
					varp
					
				
			
		
	
	
		
			
			
				
				
				
			
		
	
	
		
			
				
					
				
			
			
				
					
						self
						cell-range
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
					
				
			
		
	
	
		
			
				
					
					
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
			
			
				
					
					
				
			
			
				
			
			
				
					
				
			
			
				
					
						text
						number
					
				
			
		
	
	
		
			
				
			
			
		
	
	
		
			
				
			
		
	
	
		
			
			
				
					
					
					
					
					
				
			
			
				
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					
						none
						row
						column
						both
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
			
			
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
				
			
			
				
					
						row
						column
						data
						hidden
					
				
				
					
						page
					
					
						
					
				
			
			
				
					
				
			
			
				
					
						auto
						average
						count
						countnums
						max
						min
						product
						stdev
						stdevp
						sum
						var
						varp
						
					
				
			
			
				
					
				
			
		
	
	
		
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
		
	
	
		
			
				auto
				average
				count
				countnums
				max
				min
				product
				stdev
				stdevp
				sum
				var
				varp
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
			
			
				
			
			
				
					from-top
					from-bottom
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					
						data
					
					
						
					
				
				
					
						none
						manual
						name
					
				
			
			
				
					ascending
					descending
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					tabular-layout
					outline-subtotals-top
					outline-subtotals-bottom
				
			
			
				
			
		
	
	
		
			
		
	
	
		
			
				
			
			
				
					
						named
					
					
						
					
				
				
					
						previous
						next
					
				
			
			
				
					none
					member-difference
					member-percentage
					member-percentage-difference
					running-total
					row-percentage
					column-percentage
					total-percentage
					index
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
			
			
				
					
						
						auto
					
				
				
					
						
						auto
					
				
			
			
				
					
						
						auto
					
				
				
					
						
						auto
					
				
			
			
				
			
			
				
					seconds
					minutes
					hours
					days
					months
					quarters
					years
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
		
	
	
		
			
		
	
	
		
			
		
	
	
		
			
			
		
	
	
		
			
				
					average
					count
					countnums
					max
					min
					product
					stdev
					stdevp
					sum
					var
					varp
					
				
			
			
				
			
			
				
			
			
				
					
						none
						row
						column
						both
					
				
			
			
				
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
				
					
					
					
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
			
			
				
			
			
				
			
		
	
	
		
			
				
					row
					column
					table
				
			
			
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
			
		
	
	
		
			
				
					
					
				
			
		
	
	
		
			
				
					
				
			
			
				
			
			
				
			
		
	
	
		
			
				
					
				
			
			
		
	
	
		
			
			
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
				
					row
					column
					table
				
			
			
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
				
				
					
					
						
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
					
				
				
					
				
			
		
	
	
		
			
			
			
			
			
				
			
			
				
			
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
			
		
	
	
		
			
		
		
			
		
		
			
		
	
	
		
			
		
		
			
		
		
			
		
		
			
		
		
			
		
		
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
			
		
	
	
		
			
			
			
			
				
			
			
				
			
			
		
	
	
		
			
			
		
	
	
		
			
				
					
				
			
			
		
	
	
		
			
				
			
			
				
					
						accepted
						rejected
						pending
					
				
			
			
				
					
				
			
		
	
	
		
			
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
			
			
				
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
				
			
			
				
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					
						always
						screen
						printer
						none
					
				
			
		
	
	
		
			
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
					
					
				
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
			
			
				
					
				
			
			
				
					
					
						
							
						
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
		
	
	
		
			
			
			
			
			
			
				
			
			
				
			
			
				
			
			
				
			
			
		
	
	
		
			
				
					
				
			
			
				
					
						
					
				
				
					
						
					
				
			
		
	
	
		
			
			
			
			
				
			
			
				
			
			
				
			
			
				
			
			
		
	
	
		
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
			
			
			
			
			
			
				
			
			
				
			
			
				
			
			
				
			
			
		
	
	
		
			
		
	
	
		
			
			
			
			
			
			
			
				
			
			
				
			
			
				
			
			
				
			
			
		
	
	
		
			
			
			
			
			
			
				
			
			
				
			
			
				
			
			
				
			
			
		
	
	
		
			
				
					false
				
				
					
						true
					
					
				
			
			
				
			
		
	
	
		
			
		
	
	
		
			
			
			
			
			
			
			
				
			
			
				
			
			
				
			
			
				
			
			
		
	
	
		
			
		
	
	
		
			
				
					
					
				
				
					
					
				
			
			
			
			
			
				
			
			
				
			
			
				
			
			
				
			
			
		
	
	
		
			
		
		
			
		
	
	
		
			
		
	
	
		
			
				
					
						full
						section
						cut
						arc
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
					
				
				
					
					
				
			
			
			
			
			
				
			
			
				
			
			
				
			
			
				
			
			
		
	
	
		
			
		
		
			
		
	
	
		
			
			
			
			
			
				
			
			
				
			
			
				
			
			
				
			
			
		
	
	
		
			
				
					
						standard
						lines
						line
						curve
					
				
			
			
				
					
				
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						
						
							
							
								
							
						
					
				
			
			
				
					
				
			
		
	
	
		
			
			
			
			
			
			
				
			
			
				
			
			
				
			
			
				
			
			
		
	
	
		
			
				
					
				
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
			
			
				
			
			
				
			
			
				
			
			
				
			
			
		
	
	
		
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
			
			
			
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
		
	
	
		
			
			
			
			
			
			
			
				
			
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
			
			
			
			
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
		
			
				
			
		
	
	
		
			
				
			
		
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
				
				
				
			
		
	
	
		
			
				
					
						
					
				
				
					
						
					
				
			
			
				
					
						
					
				
				
					
						
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
				
					
						
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
		
	
	
		
			
				
					
						page
						frame
						paragraph
						char
						as-char
					
				
			
			
				
					
				
			
		
	
	
		
			
				
				
			
		
	
	
		
		
		
		
		
		
		
	
	
		
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
					
					
				
			
			
				
					
					
				
			
			
				
					
						top-left
						top
						top-right
						left
						center
						right
						bottom-left
						bottom-right
					
				
			
			
				
					auto
					left
					right
					up
					down
					horizontal
					vertical
				
			
		
	
	
		
			
		
	
	
		
			
		
	
	
		
			
			
			
			
			
			
			
				
					
					
					
					
					
					
					
					
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
					
					
				
			
		
	
	
		
		
			
				
					
					scale
					scale-min
				
			
		
		
			
				
					
					scale
					scale-min
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
				
					
					
						
							
						
					
				
			
		
	
	
		
			
			
				
				
			
			
		
	
	
		
			
				simple
			
			
				
			
			
				
					embed
				
			
			
				
					onLoad
				
			
		
	
	
		
			
		
	
	
		
			
				
					
				
			
			
				
			
		
	
	
		
			
			
				
				
				
			
		
	
	
		
			
			
				
				
			
		
	
	
		
			
				
					
						
						
					
				
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
			
		
	
	
		
			
			
				
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
			
		
	
	
		
			
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					
				
			
			
				
			
		
	
	
		
			
			
			
			
			
		
	
	
		
			
			
			
			
			
		
	
	
		
			
		
	
	
		
			
			
		
	
	
		
			
				simple
			
			
				
			
			
				
					onRequest
				
			
			
				
					
				
			
			
				
					
						new
						replace
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
			
		
	
	
		
			
				
					
					
					
				
			
		
	
	
		
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
			
				
			
			
				
			
			
				
			
			
				
			
			
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
				
					simple
				
				
					
				
				
					
						
					
				
				
					
						
							new
							replace
						
					
				
			
			
				
					
				
			
			
				
					nohref
				
			
		
	
	
		
			
			
			
			
			
			
			
			
			
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
			
			
			
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						parallel
						perspective
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						flat
						phong
						gouraud
						draft
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					
				
			
			
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
			
			
			
			
			
		
	
	
		
			
				
			
		
		
			
				
			
		
	
	
		
			
			
			
			
			
			
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
			
			
			
			
			
			
		
	
	
		
			
			
			
			
			
			
			
			
		
	
	
		
			
			
			
			
			
			
				
			
			
				
			
			
				
			
			
				
			
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
				
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
						
						
						
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						flat
						phong
						gouraud
						draft
					
				
			
			
				
					
						
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						
						
					
				
			
			
				
					
				
			
			
				
					
						parallel
						perspective
					
				
			
			
				
					
				
			
			
				
					
						
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						none
						segments
						rectangle
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						normal
						path
						shape
					
				
			
			
				
					
						path
						shape
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			non-primitive
			
		
	
	
		
			\([ ]*-?([0-9]+(\.[0-9]*)?|\.[0-9]+)((cm)|(mm)|(in)|(pt)|(pc))([ ]+-?([0-9]+(\.[0-9]*)?|\.[0-9]+)((cm)|(mm)|(in)|(pt)|(pc))){2}[ ]*\)
		
	
	
		
			-0.5
			0.5
		
	
	
		
			
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			title
			outline
			subtitle
			text
			graphic
			object
			chart
			table
			orgchart
			page
			notes
			handout
			header
			footer
			date-time
			page-number
		
	
	
		
			
				
					
					
				
			
		
	
	
		
			
			
			
			
			
			
		
	
	
		
			
			
				simple
			
			
				
			
			
				
					onRequest
				
			
			
				
					
						new
						replace
					
				
			
			
		
	
	
		
			
				
					
				
			
			
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			none
			fade
			move
			stripes
			open
			close
			dissolve
			wavyline
			random
			lines
			laser
			appear
			hide
			move-short
			checkerboard
			rotate
			stretch
		
	
	
		
			none
			from-left
			from-top
			from-right
			from-bottom
			from-center
			from-upper-left
			from-upper-right
			from-lower-left
			from-lower-right
			to-left
			to-top
			to-right
			to-bottom
			to-upper-left
			to-upper-right
			to-lower-right
			to-lower-left
			path
			spiral-inward-left
			spiral-inward-right
			spiral-outward-left
			spiral-outward-right
			vertical
			horizontal
			to-center
			clockwise
			counter-clockwise
		
	
	
		
			slow
			medium
			fast
		
	
	
		
			
			
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
			
			
				
			
		
	
	
		
			
			
		
	
	
		
			
		
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
					
						default
						on-click
						with-previous
						after-previous
						timing-root
						main-sequence
						interactive-sequence
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						custom
						entrance
						exit
						emphasis
						motion-path
						ole-action
						media-call
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
					
						
							
						
					
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
			
			
				
					none
					previous-page
					next-page
					first-page
					last-page
					hide
					stop
					execute
					show
					verb
					fade-out
					sound
					last-visited-page
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					simple
				
				
					
				
				
					
						embed
					
				
				
					
						onRequest
					
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
				
				
			
			
				
				
			
			
				
				
			
		
	
	
		
			
		
	
	
		
			
		
	
	
		
			
				
			
			
				
					fixed
					current-date
				
			
			
				
					
				
			
		
	
	
		
			
				
				
					
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						enabled
						disabled
					
				
			
			
				
					
						enabled
						disabled
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
			
		
	
	
		
			
			
				
			
			
				
			
			
				
			
			
				
			
			
			
				
			
		
	
	
		
			
				
			
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						simple
					
					
						
					
				
			
			
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
					
				
			
			
			
				
					
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
					
						
							start
							end
							top
							bottom
						
					
					
						
							
								start
								center
								end
							
						
					
				
				
					
						top-start
						bottom-start
						top-end
						bottom-end
					
				
				
			
			
			
				
					
						wide
						high
						balanced
					
				
				
					
						custom
					
					
						
					
				
				
			
			
				
					
				
			
		
	
	
		
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						none
						row
						column
						both
					
				
			
			
			
			
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			x
			y
			z
		
	
	
		
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
				
					
						major
						minor
					
				
			
			
				
					
				
			
		
	
	
		
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
			
		
	
	
		
			
				
					
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					
				
			
			
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
		
	
	
		
			
		
	
	
		
			
				
			
		
	
	
		
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
			
			
				
			
			
				
			
		
	
	
		
	
	
		
			
			
				
				
			
			
				
			
		
	
	
		
	
	
		
			
			
				
				
			
		
	
	
		
	
	
		
			
		
	
	
		
			
				simple
			
			
				
			
			
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
				
			
			
				
					
				
			
		
	
	
		
			
		
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
		
	
	
		
			simple
		
		
			
		
		
			
				none
			
		
		
			
				onRequest
			
		
	
	
		
			
			
		
	
	
		
			
				
					
						
					
					
						
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
			
				
					
				
			
			
				
					
				
			
			
			
				
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
				
			
			
				
			
			
		
	
	
		
		
	
	
		
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						equal-integer
						is-boolean
						equal-boolean
						equal-use-only-zero
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
				
			
			
				
			
		
	
	
		
	
	
		
			
			
				
			
		
	
	
		
	
	
		
			
			
				
			
		
	
	
		
	
	
		
			
			
		
	
	
		
	
	
		
			
			
				
			
		
	
	
		
	
	
		
			
			
		
	
	
		
	
	
		
			
			
				
			
		
	
	
		
	
	
		
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
			
			
				
			
		
	
	
		
			boolean
			short
			int
			long
			double
			string
		
	
	
		
			
			
		
	
	
		
	
	
		
			
			
				
					
					
				
			
		
	
	
		
	
	
		
			
			
				
					
					
				
			
		
	
	
		
	
	
		
			
			
			
			
			
				
					
					
				
			
		
	
	
		
	
	
		
			
			
			
			
			
				
					
					
				
			
		
	
	
		
			
				
					simple
				
				
					
				
				
					
						none
					
				
				
					
						onRequest
					
				
			
			
				
					
				
			
		
	
	
		
			
			
				
					
					
				
			
		
	
	
		
	
	
		
			
			
			
			
			
				
					
					
				
			
		
	
	
		
	
	
		
			
			
			
			
			
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
				
			
			
				
					
				
			
		
	
	
		
			
			
			
		
	
	
		
			
			
			
		
	
	
		
			
		
	
	
		
			
			
				
			
		
	
	
		
	
	
		
			
			
			
			
			
			
				
			
			
				
			
			
				
			
		
	
	
		
	
	
		
			
			
				
			
		
	
	
		
	
	
		
			
			
			
			
			
		
	
	
		
			
				
					
				
			
	
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
			
		
	
	
		
	
	
		
			
			
				
			
		
	
	
		
	
	
		
			
			
			
			
				
			
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
				
			
		
	
	
		
	
	
		
			
			
		
	
	
		
			
				
			
	
			
				
					
				
			
	
			
				
					
				
			
	
			
				
					
				
			
	
			
				
					
				
			
	
			
				
					
						no-nulls
						nullable
					
				
			
	
			
				
					
				
			
	
			
				
					
				
			
		
	
	
		
			bit
			boolean
			tinyint
			smallint
			integer
			bigint
			float
			real
			double
			numeric
			decimal
			char
			varchar
			longvarchar
			date
			time
			timestmp
			binary
			varbinary
			longvarbinary
			sqlnull
			other
			object
			distinct
			struct
			array
			blob
			clob
			ref
		
	
	
		
			
			
				
			
		
	
	
		
	
	
		
			
			
				
			
		
	
	
		
			
				
					
				
			
	
			
				
					primary
					unique
					foreign
				
			
	
			
				
					
				
			
	
			
				
					
						cascade
						restrict
						set-null
						no-action
						set-default
					
				
			
	
			
				
					
						cascade
						restrict
						set-null
						no-action
						set-default
					
				
			
		
	
	
		
			
			
				
			
		
	
	
		
	
	
		
			
			
		
	
	
		
			
				
					
				
			
	
			
				
					
				
			
		
	
	
		
			
			
				
			
		
	
	
		
	
	
		
			
			
				
			
		
	
	
		
			
				
			
	
			
				
					
				
			
	
			
				
					
				
			
	
			
				
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
	
			
				
					
				
			
		
	
	
		
			
				
				
					
						
						
					
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
			
				
			
			
				
			
			
				
					
					
				
			
			
				
			
		
	
	
		
			
				
					simple
				
				
					
				
				
					
						onRequest
					
				
			
			
				
					
				
			
			
				
					
						get
						post
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						table
						query
						command
					
				
			
			
				
					
				
			
			
				
					
						
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			none
			current
			parent
		
	
	
		
			records
			current
			page
		
	
	
		
			
				
			
			
		
	
	
		
			
		
	
	
		
			
				
				
			
			
				
				
				
					
				
			
			
				
				
			
			
				
				
				
				
				
				
				
			
			
				
				
				
				
				
				
				
			
			
				
				
				
				
				
				
				
			
			
				
				
				
					
				
			
			
				
				
				
					
				
			
			
				
				
			
		
	
	
		
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
			
			
				
				
				
					
				
			
			
				
				
			
			
				
				
			
		
	
	
		
		
		
		
		
		
		
		
		
		
		
		
	
	
		
		
		
	
	
		
			
		
		
			
		
	
	
		
		
		
		
		
		
		
		
		
		
		
		
	
	
		
			
			
			
			
			
			
			
			
			
			
				
					
				
			
		
	
	
		
		
		
		
		
		
		
		
		
		
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
		
		
		
		
		
		
		
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
			
			
			
			
			
				
					
				
			
		
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					selection
					selection-indices
				
			
		
	
	
		
			
			
		
	
	
		
		
		
		
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
		
		
		
		
		
		
		
		
		
	
	
		
			
			
			
			
			
			
			
			
			
			
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			unchecked
			checked
			unknown
		
	
	
		
		
		
		
		
		
		
		
		
		
		
		
		
	
	
		
		
		
		
		
		
	
	
		
		
		
		
		
		
		
	
	
		
		
	
	
		
		
		
		
		
	
	
		
			
			
				
			
		
	
	
		
		
		
	
	
		
			
				
			
		
	
	
		
			
			
			
			
			
			
			
			
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						horizontal
						vertical
					
				
			
		
	
	
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			submit
			reset
			push
			url
		
	
	
		
			
				
			
		
	
	
		
			
			
				
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
					flat
					3d
				
			
		
	
	
		
			
				
					center
				
			
			
				
					
						start
						end
						top
						bottom
					
				
				
					
						
							start
							center
							end
						
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
					table
					query
					sql
					sql-pass-through
					value-list
					table-fields
				
			
		
	
	
		
			
				
					
					
				
			
		
	
	
		
			
				
					
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
				
			
			
				
				
			
		
	
	
		
			
		
	
	
		
			
			
				void
			
		
	
	
		
			
				
					float
				
				
					
						
							
						
					
				
			
			
				
					percentage
				
				
					
						
							
						
					
				
			
			
				
					currency
				
				
					
						
							
						
						
							
								
							
						
					
				
			
			
				
					date
				
				
					
						
							
						
					
				
			
			
				
					time
				
				
					
						
							
						
					
				
			
			
				
					boolean
				
				
					
						
							
						
					
				
			
			
				
					string
				
				
					
						
							
						
					
				
			
			
				void
			
		
	
	
		
			
			
			
			
			
			
				
			
			
				
			
			
				
			
			
				
					
					
				
			
		
	
	
		
			
		
	
	
		
			
				
					
				
			
			
				
			
		
	
	
		
	
	
		
			
		
	
	
		
			
		
	
	
		
			
				
			
		
		
			
				
			
		
	
	
		
			
				
					1
					i
					I
					
					
				
			
			
				
					
						a
						A
					
				
				
			
			
		
	
	
		
			
				
			
		
	
	
		
			
			
			
				
			
		
	
	
		
			
				
					
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
			
			
				
					
				
				
					
						simple
					
					
						
					
					
						
							onRequest
						
					
				
			
		
	
	
		
			
		
	
	
		To avoid inclusion of the complete MathML schema, anything is allowed within a math:math top-level element
		
			
				
					
				
				
				
					
					
				
			
		
	
	
		
			
			
		
	
	
		
			
		
	
	
		
			
				
			
			
				
			
			
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
			
				
					
				
			
			
				
					
						into-default-style-data-style
						into-english-number
						keep-text
					
				
			
		
	
	
		
			
				
				
				
				
				
				
				
			
			
				
				
				
				
				
			
			
				
				
				
				
				
				
				
			
			
				
				
				
				
				
				
				
				
			
			
				
				
				
				
				
				
			
			
				
				
				
				
				
				
			
			
				
				
				
				
					
				
			
			
				
				
				
				
					
				
			
			
				
				
				
				
				
					
				
			
			
				
				
				
			
			
				
				
				
				
				
					
						
							
						
						
							
						
					
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
						discrete
						linear
						paced
						spline
					
				
			
		
	
	
		
			
				
					
						rgb
						hsl
					
				
			
			
				
					
						clockwise
						counter-clockwise
					
				
			
		
	
	
		
			
				translate
				scale
				rotate
				skewX
				skewY
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					
						forward
						reverse
					
				
			
			
				
					
				
			
			
				
					
						in
						out
					
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					discrete
					linear
					paced
					spline
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
						none
						sum
					
				
			
			
				
					
						replace
						sum
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
					first
					last
					all
					media
					
				
			
		
	
	
		
			
				
			
		
		
			
				
					
					indefinite
				
			
		
	
	
		
			0.0
		
	
	
		
			
				
					remove
					freeze
					hold
					auto
					default
					transition
				
			
		
	
	
		
			
				
					remove
					freeze
					hold
					transition
					auto
					inherit
				
			
		
	
	
		
			
				
					never
					always
					whenNotActive
					default
				
			
		
	
	
		
			
				
					never
					always
					whenNotActive
					inherit
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			0
			1
		
	
	
		
		
		
		
		
		
		
	
	
		
		
	
	
		
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
			
			
				
			
		
	
	
		
			
		
		
			
		
		
	
	
		
			
				
			
		
		
			
				
			
		
	
	
		
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						
						
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
			
		
	
	
		
			
		
		
			
		
		
			
		
	
	
		
			
				
			
			
				
					
						all
						left
						right
						mirrored
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
		
	
	
		
			
			
				
				
					
				
			
			
				
				
					
				
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
			
				
				
				
					
						
						
						
						
						
						
						
						
						
						
						
						
						
						
					
				
			
			
				
					
				
				
					
				
				
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
		
	
	
		
			
		
	
	
		
			
		
	
	
		
			
		
	
	
		
			
			
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
				
			
			
				
			
			
				
			
			
				
			
			
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
				
			
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			row
			column
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
			
		
		
			
				
			
		
	
	
		
			
			
		
	
	
		
			
		
	
	
		
			
			
				
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						normal
						ultra-condensed
						extra-condensed
						condensed
						semi-condensed
						semi-expanded
						expanded
						extra-expanded
						ultra-expanded
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
					
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
					
				
			
			
		
	
	
		
			
				
					
				
			
			
		
	
	
		
			
			
		
	
	
		
			simple
		
		
			
		
		
			
				onRequest
			
		
	
	
		
			
			
				
			
			
				
			
			
				
				
					
				
			
			
				
			
		
	
	
		
			
			
			
		
	
	
		
			
			
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
		
	
	
		
			
			
			
			
		
	
	
		
			
				
			
		
	
	
		
			
			
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
			
				
			
			
				
			
			
				
					
						
						
							
						
					
					
						
						
							
						
					
				
			
			
				
			
		
	
	
		
		
			
		
	
	
		
		
			
		
	
	
		
			
			
		
	
	
		
			
				
			
		
		
			
				
			
		
		
			
				
			
		
		
			
				
			
		
	
	
		
			
			
				
			
			
				
			
			
				
			
			
				
			
		
	
	
		
			
			
			
			
				
			
			
				
			
			
				
				
					
				
			
			
				
			
		
	
	
		
			
			
			
			
			
			
			
			
			
			
			
		
	
	
		
			
			
			
		
	
	
		
			
				
					short
					long
				
			
		
	
	
		
			
			
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
						short
						long
					
				
			
		
	
	
		
			
			
			
		
	
	
		
			
				
					short
					long
				
			
		
	
	
		
			
			
			
		
	
	
		
			
				
					short
					long
				
			
		
	
	
		
			
			
			
		
	
	
		
			
				
					short
					long
				
			
		
	
	
		
			
			
		
	
	
		
			
			
			
		
	
	
		
			
				
					short
					long
				
			
		
	
	
		
			
			
			
			
				
			
			
				
			
			
				
				
					
				
			
			
				
			
		
	
	
		
			
			
			
			
		
	
	
		
			
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					short
					long
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					short
					long
				
			
		
	
	
		
			
			
		
	
	
		
			
				
					
						short
						long
					
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
			
				
			
			
				
			
			
				
				
					
				
			
			
				
			
		
	
	
		
			
		
	
	
		
			
			
				
			
			
				
			
			
				
				
					
				
			
			
				
			
		
	
	
		
			
		
	
	
		
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						short
						medium
						long
					
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
					fixed
					language
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					gregorian
					gengou
					ROC
					hanja_yoil
					hanja
					hijri
					jewish
					buddhist
					
				
			
		
	
	
		
			
				
					text
				
				
					
				
			
			
				
					paragraph
				
				
					
				
				
					
				
			
			
				
					section
				
				
					
				
			
			
				
					ruby
				
				
					
				
			
			
				
					table
				
				
					
				
			
			
				
					table-column
				
				
					
				
			
			
				
					table-row
				
				
					
				
			
			
				
					table-cell
				
				
					
				
				
					
				
				
					
				
			
			
				
					
						graphic
						presentation
					
				
				
					
				
				
					
				
				
					
				
			
			
				
					drawing-page
				
				
					
				
			
			
				
					chart
				
				
					
				
				
					
				
				
					
				
				
					
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						left
						right
						inner
						outer
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
				
			
			
		
	
	
		
			
		
	
	
		
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
			
				
			
			
				
					
						document
						chapter
						page
					
				
			
			
				
					
						text
						page
						section
						document
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				address
				annote
				author
				bibliography-type
				booktitle
				chapter
				custom1
				custom2
				custom3
				custom4
				custom5
				edition
				editor
				howpublished
				identifier
				institution
				isbn
				issn
				journal
				month
				note
				number
				organizations
				pages
				publisher
				report-type
				school
				series
				title
				url
				volume
				year
			
		
		
			
				
			
		
	
	
		
			
			
				
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
				
				
					
				
				
					
				
			
			
				
				
				
					
				
				
					
				
			
			
				
				
				
					
				
			
		
	
	
		
			
				
					
				
			
			
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
				
			
			
				
			
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
		
	
	
		
			
			
				
			
		
	
	
		
			
		
	
	
		
			
			
				
			
			
				
			
		
	
	
		
			
				
			
			
				
					
				
			
			
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
		
		
	
	
		
			
		
	
	
		
		
		
	
	
		
			
			
			
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			linear
			axial
			radial
			ellipsoid
			square
			rectangular
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
				
			
		
	
	
		
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
				
			
		
	
	
		
			
				
					
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					objectBoundingBox
				
			
			
				
					
				
			
			
				
					
						pad
						reflect
						repeat
					
				
			
			
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					single
					double
					triple
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
				simple
			
			
				
			
			
				
					embed
				
			
			
				
					onLoad
				
			
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
			
		
	
	
		
			
				
			
		
		
			
				
			
		
	
	
		
			
			
			
			
		
	
	
		
			
				
			
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					
						rect
						round
					
				
			
			
				
					
				
			
			
				
					
						
						
					
				
			
			
				
					
				
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
			
		
	
	
		
			
				
			
			
				
					
					
				
			
			
				
					
					
				
			
			
				
					
					
				
			
			
				
					
					
				
			
			
		
	
	
		
			
		
	
	
		
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
			
			
			
				
					
						default
						
					
				
			
			
				
					
						portrait
						landscape
					
				
			
			
			
			
			
			
			
			
			
			
				
					
				
			
			
				
					
						
							
								headers
								grid
								annotations
								objects
								charts
								drawings
								formulas
								zero-values
							
						
					
				
			
			
				
					
						ttb
						ltr
					
				
			
			
				
					
						
						continue
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						horizontal
						vertical
						both
						none
					
				
			
			
				
					
				
			
			
			
				
					
						none
						line
						both
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
			
			
		
	
	
		
			
				
				
			
		
	
	
		
			
				
			
		
		
			
				
			
		
		
			
				
			
		
		
			
				
			
		
		
			
				
					left
					center
					right
				
			
		
		
			
				
			
		
		
			
				
			
		
	
	
		
			
		
	
	
		
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
			
			
			
			
			
			
			
			
				
					
				
			
		
	
	
		
	
	
		
			
		
	
	
		
		
	
	
		
	
	
		
			
				
					
				
			
			
				
					
						none
						lowercase
						uppercase
						capitalize
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						font-color
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						
							
							super
							sub
						
						
							
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						latin
						asian
						complex
						ignore
					
				
			
			
				
					
						
						normal
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						none
						embossed
						engraved
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						font-color
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						font-color
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
			
				
					
						none
						letters
						lines
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						none
						
							
								none
								accent
								dot
								circle
								disc
							
							
								above
								below
							
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						fixed
						line-height
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					true
				
				
					none
				
				
					
						condition
					
					
						none
					
				
				
			
		
	
	
		
			normal
			small-caps
		
	
	
		
			roman
			swiss
			modern
			decorative
			script
			system
		
	
	
		
			fixed
			variable
		
	
	
		
			[A-Za-z][A-Za-z0-9._\-]*
		
	
	
		
			normal
			italic
			oblique
		
	
	
		
			none
			
		
	
	
		
			none
			single
			double
		
	
	
		
			none
			solid
			dotted
			dash
			long-dash
			dot-dash
			dot-dot-dash
			wave
		
	
	
		
			auto
			normal
			bold
			thin
			medium
			thick
			
			
			
		
	
	
		
			normal
			bold
			100
			200
			300
			400
			500
			600
			700
			800
			900
		
	
	
		
			continuous
			skip-white-space
		
	
	
		
			
		
	
	
		
		
	
	
		
			
				
					
						normal
						
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
			
				
					
						start
						center
						justify
					
				
			
			
				
					
				
			
			
				
					
						auto
						always
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						auto
						page
					
				
			
			
				
					
						no-limit
						
					
				
			
			
				
					
				
			
	
			
			
				
					
						
						
					
				
			
			
				
					
				
			
			
			
			
			
			
			
			
				
					
				
			
			
			
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						none
						ideograph-alpha
					
				
			
			
				
					
						simple
						hanging
					
				
			
			
				
					
						normal
						strict
					
				
			
			
				
					
						top
						middle
						bottom
						auto
						baseline
					
				
			
			
			
				
					
				
			
			
				
					
				
			
			
			
		
	
	
		
			
				
					start
					end
					left
					right
					center
					justify
				
			
		
	
	
		
			
			
			
		
	
	
		
			
				
					
				
			
		
	
	
		
			
			
		
	
	
		
			
				
			
			
				
					
						
							left
							center
							right
						
					
				
				
					
						char
					
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						font-color
						
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
				
				
			
		
	
	
		
			
				
					
						word
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
					
				
			
		
		
			
				
					
					
				
			
		
	
	
		
			
				
					
					
				
			
		
		
			
				
					
					
				
			
		
	
	
		
			
				
					
					
				
			
		
	
	
		
			
				
					auto
					column
					page
				
			
		
		
			
				
					auto
					column
					page
				
			
		
	
	
		
			
				
					transparent
					
				
			
		
	
	
		
			
				
				
					
					
					
				
			
		
	
	
		
			
				
					
						no-repeat
						repeat
						stretch
					
				
			
			
				
					
						left
						center
						right
						top
						bottom
						
							
							
						
						
							
							
						
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			left
			center
			right
		
	
	
		
			top
			center
			bottom
		
	
	
		
			
				
			
		
		
			
				
			
		
		
			
				
			
		
		
			
				
			
		
		
			
				
			
		
	
	
		
			
				
			
		
		
			
				
			
		
		
			
				
			
		
		
			
				
			
		
		
			
				
			
		
	
	
		
			
			
			
		
	
	
		
			
				
			
		
		
			
				
			
		
		
			
				
			
		
		
			
				
			
		
		
			
				
			
		
	
	
		
			
				
			
		
	
	
		
			
				
					auto
					always
				
			
		
	
	
		
			
				
					lr-tb
					rl-tb
					tb-rl
					tb-lr
					lr
					rl
					tb
					page
				
			
		
	
	
		
			
				
					
					auto
				
			
		
	
	
		
			
				
			
		
	
	
		
			
		
	
	
		
		
	
	
		
	
	
		
			
				
					
						above
						below
					
				
			
			
				
					
						left
						center
						right
						distribute-letter
						distribute-space
					
				
			
		
	
	
		
			
		
	
	
		
		
	
	
		
			
			
			
				
					
				
			
			
			
				
					
				
			
			
		
	
	
		
			
			
			
				
			
		
	
	
		
			
				
				
					
				
				
					
				
			
		
	
	
		
			
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
			
				
					
						none
						solid
						dotted
						dashed
						dot-dashed
					
				
			
			
				
			
			
				
					
				
			
			
				
					
						top
						middle
						bottom
					
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
						left
						center
						right
						margins
					
				
			
			
			
			
			
			
			
			
			
			
				
					
				
			
			
				
					
						collapsing
						separating
					
				
			
			
			
				
					
				
			
		
	
	
		
	
	
		
			
		
	
	
		
		
	
	
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
		
	
	
		
			
		
	
	
		
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
			
			
				
					
						auto
						always
					
				
			
		
	
	
		
	
	
		
			
		
	
	
		
		
	
	
		
			
				
					
						top
						middle
						bottom
						automatic
					
				
			
			
				
					
						fix
						value-type
					
				
			
			
			
				
					
						auto
						0
						0deg
						0rad
						0grad
					
				
			
			
			
			
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
			
			
				
					
						no-wrap
						wrap
					
				
			
			
			
				
					
						none
						bottom
						top
						center
					
				
			
			
				
					
						none
						hidden-and-protected
						
							
								
									protected
									formula-hidden
								
							
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					ltr
					ttb
				
			
		
	
	
		
	
	
		
			
				
			
		
	
	
		
			
		
	
	
		
		
	
	
		
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
			
			
				
					
						label-width-and-position
						label-alignment
					
				
			
		
	
	
		
	
	
		
			
				
				
			
		
	
	
		
			
				
					listtab
					space
					nothing
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
						none
						dash
						solid
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						
							0
							1
						
						
					
				
			
			
				
					
						miter
						round
						bevel
						middle
						none
					
				
			
			
				
					
						butt
						square
						round
					
				
			
			
				
					
				
			
			
				
					
						none
						scroll
						alternate
						slide
					
				
			
			
				
					
						left
						right
						up
						down
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						top
						middle
						bottom
						justify
					
				
			
			
				
					
						left
						center
						right
						justify
					
				
			
			
				
					
						no-wrap
						wrap
					
				
			
			
				
					
				
			
			
				
					
						greyscale
						mono
						watermark
						standard
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						visible
						hidden
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						below
						above
					
				
			
			
				
					
				
			
			
				
					
						automatic
						left-outside
						inside
						right-outside
					
				
			
			
				
					
						automatic
						above
						below
						center
					
				
			
			
				
					
						automatic
						mm
						cm
						m
						km
						pt
						pc
						inch
						ft
						mi
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						straight-line
						angled-line
						angled-connector-line
					
				
			
			
				
					
						fixed
						free
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						horizontal
						vertical
						auto
					
				
			
			
				
					
						
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						correct
						attractive
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						enabled
						disabled
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						standard
						double-sided
					
				
			
			
				
					
						object
						flat
						sphere
					
				
			
			
				
					
						normal
						inverse
					
				
			
			
				
					
						object
						parallel
						sphere
					
				
			
			
				
					
						object
						parallel
						sphere
					
				
			
			
				
					
						luminance
						intensity
						color
					
				
			
			
				
					
						enabled
						disabled
					
				
			
			
				
					
						replace
						modulate
						blend
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						visible
						hidden
					
				
			
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
			
			
			
				
					
				
			
			
				
					
						none
						
							
								
									content
									position
									size
								
							
						
					
				
			
			
				
					
						left
						center
						right
						from-left
						inside
						outside
						from-inside
					
				
			
			
				
					
				
			
			
				
					
						page
						page-content
						page-start-margin
						page-end-margin
						frame
						frame-content
						frame-start-margin
						frame-end-margin
						paragraph
						paragraph-content
						paragraph-start-margin
						paragraph-end-margin
						char
					
				
			
			
			
			
			
			
			
			
			
			
			
			
				
					
						none
						left
						right
						parallel
						dynamic
						run-through
						biggest
					
				
			
			
				
					
				
			
			
				
					
						no-limit
						
					
				
			
			
				
					
				
			
			
				
					
						full
						outside
					
				
			
			
				
					
						foreground
						background
					
				
			
			
				
					
				
			
			
				
					
						clip
						auto-create-new-frame
					
				
			
			
				
					
						none
						vertical
						
						
							vertical
							
						
						
							
							vertical
						
					
				
			
			
				
					
						auto
						
					
				
			
			
				
					
						iterative
						once-concurrent
						once-successive
					
				
			
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						content
						thumbnail
						icon
						print-view
					
				
			
			
				
					
				
			
		
	
	
		
			
				
					
						none
						solid
						bitmap
						gradient
						hatch
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						no-repeat
						repeat
						stretch
					
				
			
			
				
					
						
						
					
				
			
			
				
					
						
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						top-left
						top
						top-right
						left
						center
						right
						bottom-left
						bottom
						bottom-right
					
				
			
			
				
					
						
						
							horizontal
							vertical
						
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						nonzero
						evenodd
					
				
			
		
	
	
		
			
				
			
			
			
		
	
	
		
			
				
					top
					middle
					bottom
					from-top
					below
				
			
		
		
			
				
			
		
	
	
		
			
				
					page
					page-content
					frame
					frame-content
					paragraph
					paragraph-content
					char
					line
					baseline
					text
				
			
		
	
	
		
			
				
			
		
	
	
		
			horizontal
			horizontal-on-odd
			horizontal-on-even
		
	
	
		
			rect\([ ]*((-?([0-9]+(\.[0-9]*)?|\.[0-9]+)((cm)|(mm)|(in)|(pt)|(pc)))|(auto))([ ]*,[ ]*((-?([0-9]+(\.[0-9]*)?|\.[0-9]+)((cm)|(mm)|(in)|(pt)|(pc))))|(auto)){3}[ ]*\)
		
	
	
		
			([0-9]+(\.[0-9]*)?|\.[0-9]+)(px)
		
	
	
		
			
		
	
	
		
		
	
	
		
	
	
		
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					none
				
				
					automatic
				
				
					
						named-symbol
					
					
						
							square
							diamond
							arrow-down
							arrow-up
							arrow-right
							arrow-left
							bow-tie
							hourglass
							circle
							star
							x
							plus
							asterisk
							horizontal-bar
							vertical-bar
						
					
				
				
					
						image
					
					
						
							
						
					
				
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						none
						cubic-spline
						b-spline
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						cuboid
						cylinder
						cone
						pyramid
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						use-zero
						leave-gap
						ignore
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						side-by-side
						stagger-even
						stagger-odd
					
				
			
			
			
			
				
					
						none
						value
						percentage
						value-and-percentage
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						none
						variance
						standard-deviation
						percentage
						error-margin
						constant
						standard-error
						cell-range
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						columns
						rows
					
				
			
			
				
					
						none
						linear
						logarithmic
						exponential
						power
					
				
			
			
				
					
						start
						end
						
					
				
			
			
				
					
						near-axis
						near-axis-other-side
						outside-start
						outside-end
					
				
			
			
				
					
						at-labels
						at-axis
						at-labels-and-axis
					
				
			
			
				
					
				
			
		
	
	
		
			avoid-overlap
			center
			top
			top-right
			right
			bottom-right
			bottom
			bottom-left
			left
			top-left
			inside
			outside
			near-origin
		
	
	
		
			
				
					
						manual
						automatic
						semi-automatic
					
				
			
			
				
					
						none
						fade-from-left
						fade-from-top
						fade-from-right
						fade-from-bottom
						fade-from-upperleft
						fade-from-upperright
						fade-from-lowerleft
						fade-from-lowerright
						move-from-left
						move-from-top
						move-from-right
						move-from-bottom
						move-from-upperleft
						move-from-upperright
						move-from-lowerleft
						move-from-lowerright
						uncover-to-left
						uncover-to-top
						uncover-to-right
						uncover-to-bottom
						uncover-to-upperleft
						uncover-to-upperright
						uncover-to-lowerleft
						uncover-to-lowerright
						fade-to-center
						fade-from-center
						vertical-stripes
						horizontal-stripes
						clockwise
						counterclockwise
						open-vertical
						open-horizontal
						close-vertical
						close-horizontal
						wavyline-from-left
						wavyline-from-top
						wavyline-from-right
						wavyline-from-bottom
						spiralin-left
						spiralin-right
						spiralout-left
						spiralout-right
						roll-from-top
						roll-from-left
						roll-from-right
						roll-from-bottom
						stretch-from-left
						stretch-from-top
						stretch-from-right
						stretch-from-bottom
						vertical-lines
						horizontal-lines
						dissolve
						random
						vertical-checkerboard
						horizontal-checkerboard
						interlocking-horizontal-left
						interlocking-horizontal-right
						interlocking-vertical-top
						interlocking-vertical-bottom
						fly-away
						open
						close
						melt
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						forward
						reverse
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
						visible
						hidden
					
				
			
			
				
					
						full
						border
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
			
				
					
				
			
		
	
	
		
			
		
	
	
		
	
	
		
	
	
		
	
	
		
	
	
		
	
	
		
	
	
		
	
	
		
	
	
		
	
	
		
	
	
		
	
	
		
	
	
		
	
	
		
	
	
		
	
	
		
			true
			false
		
	
	
		
			
			
		
	
	
		
			
			
		
	
	
		
	
	
		
			[A-Za-z0-9]{1,8}
		
	
	
		
			[A-Za-z]{1,8}
		
	
	
		
			[A-Za-z0-9]{1,8}
		
	
	
		
			1
		
	
	
		
			-?([0-9]+(\.[0-9]*)?|\.[0-9]+)((cm)|(mm)|(in)|(pt)|(pc)|(px))
		
	
	
		
			([0-9]+(\.[0-9]*)?|\.[0-9]+)((cm)|(mm)|(in)|(pt)|(pc)|(px))
		
	
	
		
			([0-9]*[1-9][0-9]*(\.[0-9]*)?|0+\.[0-9]*[1-9][0-9]*|\.[0-9]*[1-9][0-9]*)((cm)|(mm)|(in)|(pt)|(pc)|(px))
		
	
	
		
			-?([0-9]+(\.[0-9]*)?|\.[0-9]+)%
		
	
	
		
			([0-9]?[0-9](\.[0-9]*)?|100(\.0*)?|\.[0-9]+)%
		
	
	
		
			-?([0-9]?[0-9](\.[0-9]*)?|100(\.0*)?|\.[0-9]+)%
		
	
	
		
			[0-9]+\*
		
	
	
		
	
	
		
	
	
		
			#[0-9a-fA-F]{6}
		
	
	
		
	
	
		
			(([\i-[:]][\c-[:]]*)?:)?.+
			1
		
	
	
		
			
				
			
		
	
	
		
			\[(([\i-[:]][\c-[:]]*)?:)?.+\]
			3
		
	
	
		
			
			
		
	
	
		
	
	
		
			
			
		
	
	
		
			
				
			
		
	
	
		
	
	
		
			_self
			_blank
			_parent
			_top
			
		
	
	
		
			float
			time
			date
			percentage
			currency
			boolean
			string
		
	
	
		
			-?[0-9]+,-?[0-9]+([ ]+-?[0-9]+,-?[0-9]+)*
		
	
	
		
	
	
		
			\([ ]*-?([0-9]+(\.[0-9]*)?|\.[0-9]+)([ ]+-?([0-9]+(\.[0-9]*)?|\.[0-9]+)){2}[ ]*\)
		
	
	
		
			[^:]+:[^:]+
		
	
	
		
		An IRI-reference as defined in [RFC3987]. See ODF 1.2 Part 1 section 18.3. 
	
	
		
			
				
				
			
		
		
	
	
		
			
				
				
					
				
			
		
	





© 2015 - 2024 Weber Informatics LLC | Privacy Policy