[deliverable/binutils-gdb.git] / ld / scripttempl / elfppc.sc

#
# Unusual variables checked by this code:
#	NOP - two byte opcode for no-op (defaults to 0)
#	DATA_ADDR - if end-of-text-plus-one-page isn't right for data start
#	OTHER_READONLY_SECTIONS - other than .text .init .rodata ...
#		(e.g., .PARISC.milli)
#	OTHER_READWRITE_SECTIONS - other than .data .bss .ctors .sdata ...
#		(e.g., .PARISC.global)
#	OTHER_SECTIONS - at the end
#	EXECUTABLE_SYMBOLS - symbols that must be defined for an
#		executable (e.g., _DYNAMIC_LINK)
#	TEXT_START_SYMBOLS - symbols that appear at the start of the
#		.text section.
#	DATA_START_SYMBOLS - symbols that appear at the start of the
#		.data section.
#	OTHER_BSS_SYMBOLS - symbols that appear at the start of the
#		.bss section besides __bss_start.
#
# When adding sections, do note that the names of some sections are used
# when specifying the start address of the next.
#
test -z "$ENTRY" && ENTRY=_start
test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
test "$LD_FLAG" = "N" && DATA_ADDR=.
SBSS2=".sbss2 ${RELOCATING-0} : { *(.sbss2) }"
SDATA2=".sdata2 ${RELOCATING-0} : { *(.sdata2) }"
INTERP=".interp ${RELOCATING-0} : { *(.interp) }"
PLT=".plt ${RELOCATING-0} : { *(.plt) }"
cat <<EOF
OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
	      "${LITTLE_OUTPUT_FORMAT}")
OUTPUT_ARCH(${ARCH})
ENTRY(${ENTRY})

${RELOCATING+${LIB_SEARCH_DIRS}}
${RELOCATING+/* Do we need any of these for elf?
   __DYNAMIC = 0; ${STACKZERO+${STACKZERO}} ${SHLIB_PATH+${SHLIB_PATH}}  */}
${RELOCATING+${EXECUTABLE_SYMBOLS}}
${RELOCATING- /* For some reason, the Solaris linker makes bad executables
  if gld -r is used and the intermediate file has sections starting
  at non-zero addresses.  Could be a Solaris ld bug, could be a GNU ld
  bug.  But for now assigning the zero vmas works.  */}

${RELOCATING+PROVIDE (__stack = 0);}
SECTIONS
{
  /* Read-only sections, merged into text segment: */
  ${CREATE_SHLIB-${RELOCATING+. = ${TEXT_START_ADDR} + SIZEOF_HEADERS;}}
  ${CREATE_SHLIB+${RELOCATING+. = SIZEOF_HEADERS;}}
  ${CREATE_SHLIB-${INTERP}}
  .hash		${RELOCATING-0} : { *(.hash)		}
  .dynsym	${RELOCATING-0} : { *(.dynsym)		}
  .dynstr	${RELOCATING-0} : { *(.dynstr)		}
  .gnu.version ${RELOCATING-0} : { *(.gnu.version)      }
  .gnu.version_d ${RELOCATING-0} : { *(.gnu.version_d)  }
  .gnu.version_r ${RELOCATING-0} : { *(.gnu.version_r)  }
  .rela.text   ${RELOCATING-0} :
    { *(.rela.text) *(.rela.gnu.linkonce.t*) }
  .rela.data   ${RELOCATING-0} :
    { *(.rela.data) *(.rela.gnu.linkonce.d*) }
  .rela.rodata ${RELOCATING-0} :
    { *(.rela.rodata) *(.rela.gnu.linkonce.r*) }
  .rela.got	${RELOCATING-0} : { *(.rela.got)	}
  .rela.got1	${RELOCATING-0} : { *(.rela.got1)	}
  .rela.got2	${RELOCATING-0} : { *(.rela.got2)	}
  .rela.ctors	${RELOCATING-0} : { *(.rela.ctors)	}
  .rela.dtors	${RELOCATING-0} : { *(.rela.dtors)	}
  .rela.init	${RELOCATING-0} : { *(.rela.init)	}
  .rela.fini	${RELOCATING-0} : { *(.rela.fini)	}
  .rela.bss	${RELOCATING-0} : { *(.rela.bss)	}
  .rela.plt	${RELOCATING-0} : { *(.rela.plt)	}
  .rela.sdata	${RELOCATING-0} : { *(.rela.sdata)	}
  .rela.sbss	${RELOCATING-0} : { *(.rela.sbss)	}
  .rela.sdata2	${RELOCATING-0} : { *(.rela.sdata2)	}
  .rela.sbss2	${RELOCATING-0} : { *(.rela.sbss2)	}
  .text    ${RELOCATING-0} :
  {
    ${RELOCATING+${TEXT_START_SYMBOLS}}
    *(.text)
    /* .gnu.warning sections are handled specially by elf32.em.  */
    *(.gnu.warning)
    *(.gnu.linkonce.t*)
  } =${NOP-0}
  .init		${RELOCATING-0} : { *(.init)		} =${NOP-0}
  .fini		${RELOCATING-0} : { *(.fini)		} =${NOP-0}
  .rodata	${RELOCATING-0} : { *(.rodata) *(.gnu.linkonce.r*) }
  .rodata1	${RELOCATING-0} : { *(.rodata1) }
  ${RELOCATING+_etext = .;}
  ${RELOCATING+PROVIDE (etext = .);}
  ${CREATE_SHLIB-${SDATA2}}
  ${CREATE_SHLIB-${SBSS2}}
  ${RELOCATING+${OTHER_READONLY_SECTIONS}}

  /* Adjust the address for the data segment.  We want to adjust up to
     the same address within the page on the next page up.  It would
     be more correct to do this:
       ${RELOCATING+. = ${DATA_ADDR-ALIGN(${MAXPAGESIZE}) + (ALIGN(8) & (${MAXPAGESIZE} - 1))};}
     The current expression does not correctly handle the case of a
     text segment ending precisely at the end of a page; it causes the
     data segment to skip a page.  The above expression does not have
     this problem, but it will currently (2/95) cause BFD to allocate
     a single segment, combining both text and data, for this case.
     This will prevent the text segment from being shared among
     multiple executions of the program; I think that is more
     important than losing a page of the virtual address space (note
     that no actual memory is lost; the page which is skipped can not
     be referenced).  */
  ${RELOCATING+. = ${DATA_ADDR- ALIGN(8) + ${MAXPAGESIZE}};}

  .data  ${RELOCATING-0} :
  {
    ${RELOCATING+${DATA_START_SYMBOLS}}
    *(.data)
    *(.gnu.linkonce.d*)
    ${CONSTRUCTING+CONSTRUCTORS}
  }
  .data1 ${RELOCATING-0} : { *(.data1) }
  ${RELOCATING+${OTHER_READWRITE_SECTIONS}}

  .got1		${RELOCATING-0} : { *(.got1) }
  .dynamic	${RELOCATING-0} : { *(.dynamic) }

  /* Put .ctors and .dtors next to the .got2 section, so that the pointers
     get relocated with -mrelocatable. Also put in the .fixup pointers.
     The current compiler no longer needs this, but keep it around for 2.7.2  */

		${RELOCATING+PROVIDE (_GOT2_START_ = .);}
  .got2		${RELOCATING-0} :  { *(.got2) }

		${RELOCATING+PROVIDE (__CTOR_LIST__ = .);}
  .ctors	${RELOCATING-0} : { *(.ctors) }
		${RELOCATING+PROVIDE (__CTOR_END__ = .);}

		${RELOCATING+PROVIDE (__DTOR_LIST__ = .);}
  .dtors	${RELOCATING-0} : { *(.dtors) }
		${RELOCATING+PROVIDE (__DTOR_END__ = .);}

		${RELOCATING+PROVIDE (_FIXUP_START_ = .);}
  .fixup	${RELOCATING-0} : { *(.fixup) }
		${RELOCATING+PROVIDE (_FIXUP_END_ = .);}
		${RELOCATING+PROVIDE (_GOT2_END_ = .);}

		${RELOCATING+PROVIDE (_GOT_START_ = .);}
  .got		${RELOCATING-0} : { *(.got) }
  .got.plt	${RELOCATING-0} : { *(.got.plt) }
  ${CREATE_SHLIB+${SDATA2}}
  ${CREATE_SHLIB+${SBSS2}}
		${RELOCATING+PROVIDE (_GOT_END_ = .);}

  /* We want the small data sections together, so single-instruction offsets
     can access them all, and initialized data all before uninitialized, so
     we can shorten the on-disk segment size.  */
  .sdata	${RELOCATING-0} : { *(.sdata) }
  ${RELOCATING+_edata  =  .;}
  ${RELOCATING+PROVIDE (edata = .);}
  .sbss    ${RELOCATING-0} :
  {
    ${RELOCATING+PROVIDE (__sbss_start = .);}
    *(.sbss)
    *(.scommon)
    ${RELOCATING+PROVIDE (__sbss_end = .);}
  }
  ${PLT}
  .bss     ${RELOCATING-0} :
  {
   ${RELOCATING+${OTHER_BSS_SYMBOLS}}
   ${RELOCATING+PROVIDE (__bss_start = .);}
   *(.dynbss)
   *(.bss)
   *(COMMON)
  }
  ${RELOCATING+_end = . ;}
  ${RELOCATING+PROVIDE (end = .);}

  /* These are needed for ELF backends which have not yet been
     converted to the new style linker.  */
  .stab 0 : { *(.stab) }
  .stabstr 0 : { *(.stabstr) }

  /* DWARF debug sections.
     Symbols in the DWARF debugging sections are relative to the beginning
     of the section so we begin them at 0.  */

  /* DWARF 1 */
  .debug          0 : { *(.debug) }
  .line           0 : { *(.line) }

  /* GNU DWARF 1 extensions */
  .debug_srcinfo  0 : { *(.debug_srcinfo) }
  .debug_sfnames  0 : { *(.debug_sfnames) }

  /* DWARF 1.1 and DWARF 2 */
  .debug_aranges  0 : { *(.debug_aranges) }
  .debug_pubnames 0 : { *(.debug_pubnames) }

  /* DWARF 2 */
  .debug_info     0 : { *(.debug_info) }
  .debug_abbrev   0 : { *(.debug_abbrev) }
  .debug_line     0 : { *(.debug_line) }
  .debug_frame    0 : { *(.debug_frame) }
  .debug_str      0 : { *(.debug_str) }
  .debug_loc      0 : { *(.debug_loc) }
  .debug_macinfo  0 : { *(.debug_macinfo) }

  /* SGI/MIPS DWARF 2 extensions */
  .debug_weaknames 0 : { *(.debug_weaknames) }
  .debug_funcnames 0 : { *(.debug_funcnames) }
  .debug_typenames 0 : { *(.debug_typenames) }
  .debug_varnames  0 : { *(.debug_varnames) }

  /* These must appear regardless of ${RELOCATING}.  */
  ${OTHER_SECTIONS}
}
EOF
Commit	Line	Data
5f16938d MM	1	#
	2	# Unusual variables checked by this code:
	3	# NOP - two byte opcode for no-op (defaults to 0)
	4	# DATA_ADDR - if end-of-text-plus-one-page isn't right for data start
c2b6884b	5	# OTHER_READONLY_SECTIONS - other than .text .init .rodata ...
5f16938d	6	# (e.g., .PARISC.milli)
c2b6884b	7	# OTHER_READWRITE_SECTIONS - other than .data .bss .ctors .sdata ...
5f16938d MM	8	# (e.g., .PARISC.global)
	9	# OTHER_SECTIONS - at the end
	10	# EXECUTABLE_SYMBOLS - symbols that must be defined for an
	11	# executable (e.g., _DYNAMIC_LINK)
	12	# TEXT_START_SYMBOLS - symbols that appear at the start of the
	13	# .text section.
	14	# DATA_START_SYMBOLS - symbols that appear at the start of the
	15	# .data section.
	16	# OTHER_BSS_SYMBOLS - symbols that appear at the start of the
	17	# .bss section besides __bss_start.
5f16938d MM	18	#
	19	# When adding sections, do note that the names of some sections are used
	20	# when specifying the start address of the next.
	21	#
	22	test -z "$ENTRY" && ENTRY=_start
	23	test -z "${BIG_OUTPUT_FORMAT}" && BIG_OUTPUT_FORMAT=${OUTPUT_FORMAT}
	24	test -z "${LITTLE_OUTPUT_FORMAT}" && LITTLE_OUTPUT_FORMAT=${OUTPUT_FORMAT}
	25	test "$LD_FLAG" = "N" && DATA_ADDR=.
c56c9218 C	26	SBSS2=".sbss2 ${RELOCATING-0} : { *(.sbss2) }"
	27	SDATA2=".sdata2 ${RELOCATING-0} : { *(.sdata2) }"
	28	INTERP=".interp ${RELOCATING-0} : { *(.interp) }"
	29	PLT=".plt ${RELOCATING-0} : { *(.plt) }"
5f16938d MM	30	cat <<EOF
	31	OUTPUT_FORMAT("${OUTPUT_FORMAT}", "${BIG_OUTPUT_FORMAT}",
	32	"${LITTLE_OUTPUT_FORMAT}")
	33	OUTPUT_ARCH(${ARCH})
	34	ENTRY(${ENTRY})
	35
	36	${RELOCATING+${LIB_SEARCH_DIRS}}
	37	${RELOCATING+/* Do we need any of these for elf?
	38	__DYNAMIC = 0; ${STACKZERO+${STACKZERO}} ${SHLIB_PATH+${SHLIB_PATH}} */}
	39	${RELOCATING+${EXECUTABLE_SYMBOLS}}
	40	${RELOCATING- /* For some reason, the Solaris linker makes bad executables
	41	if gld -r is used and the intermediate file has sections starting
	42	at non-zero addresses. Could be a Solaris ld bug, could be a GNU ld
	43	bug. But for now assigning the zero vmas works. */}
fb2a7661 MM	44
fb2a7661 MM	45	${RELOCATING+PROVIDE (__stack = 0);}
5f16938d MM	46	SECTIONS
	47	{
	48	/* Read-only sections, merged into text segment: */
	49	${CREATE_SHLIB-${RELOCATING+. = ${TEXT_START_ADDR} + SIZEOF_HEADERS;}}
	50	${CREATE_SHLIB+${RELOCATING+. = SIZEOF_HEADERS;}}
	51	${CREATE_SHLIB-${INTERP}}
be03dc3e MM	52	.hash ${RELOCATING-0} : { *(.hash) }
	53	.dynsym ${RELOCATING-0} : { *(.dynsym) }
	54	.dynstr ${RELOCATING-0} : { *(.dynstr) }
4602e5f4 ILT	55	.gnu.version ${RELOCATING-0} : { *(.gnu.version) }
	56	.gnu.version_d ${RELOCATING-0} : { *(.gnu.version_d) }
	57	.gnu.version_r ${RELOCATING-0} : { *(.gnu.version_r) }
f5f212fb ILT	58	.rela.text ${RELOCATING-0} :
	59	{ (.rela.text) (.rela.gnu.linkonce.t*) }
	60	.rela.data ${RELOCATING-0} :
	61	{ (.rela.data) (.rela.gnu.linkonce.d*) }
	62	.rela.rodata ${RELOCATING-0} :
	63	{ (.rela.rodata) (.rela.gnu.linkonce.r*) }
be03dc3e	64	.rela.got ${RELOCATING-0} : { *(.rela.got) }
be03dc3e MM	65	.rela.got1 ${RELOCATING-0} : { *(.rela.got1) }
	66	.rela.got2 ${RELOCATING-0} : { *(.rela.got2) }
	67	.rela.ctors ${RELOCATING-0} : { *(.rela.ctors) }
	68	.rela.dtors ${RELOCATING-0} : { *(.rela.dtors) }
	69	.rela.init ${RELOCATING-0} : { *(.rela.init) }
	70	.rela.fini ${RELOCATING-0} : { *(.rela.fini) }
	71	.rela.bss ${RELOCATING-0} : { *(.rela.bss) }
	72	.rela.plt ${RELOCATING-0} : { *(.rela.plt) }
4602e5f4 ILT	73	.rela.sdata ${RELOCATING-0} : { *(.rela.sdata) }
4602e5f4 ILT	74	.rela.sbss ${RELOCATING-0} : { *(.rela.sbss) }
c2b6884b MM	75	.rela.sdata2 ${RELOCATING-0} : { *(.rela.sdata2) }
c2b6884b MM	76	.rela.sbss2 ${RELOCATING-0} : { *(.rela.sbss2) }
5f16938d MM	77	.text ${RELOCATING-0} :
	78	{
	79	${RELOCATING+${TEXT_START_SYMBOLS}}
	80	*(.text)
	81	/* .gnu.warning sections are handled specially by elf32.em. */
	82	*(.gnu.warning)
f5f212fb	83	(.gnu.linkonce.t)
5f16938d	84	} =${NOP-0}
28ad0357 MM	85	.init ${RELOCATING-0} : { *(.init) } =${NOP-0}
28ad0357 MM	86	.fini ${RELOCATING-0} : { *(.fini) } =${NOP-0}
f5f212fb	87	.rodata ${RELOCATING-0} : { (.rodata) (.gnu.linkonce.r*) }
c2b6884b	88	.rodata1 ${RELOCATING-0} : { *(.rodata1) }
28ad0357 MM	89	${RELOCATING+_etext = .;}
28ad0357 MM	90	${RELOCATING+PROVIDE (etext = .);}
c56c9218 C	91	${CREATE_SHLIB-${SDATA2}}
c56c9218 C	92	${CREATE_SHLIB-${SBSS2}}
5f16938d MM	93	${RELOCATING+${OTHER_READONLY_SECTIONS}}
5f16938d MM	94
c2b6884b MM	95	/* Adjust the address for the data segment. We want to adjust up to
	96	the same address within the page on the next page up. It would
	97	be more correct to do this:
	98	${RELOCATING+. = ${DATA_ADDR-ALIGN(${MAXPAGESIZE}) + (ALIGN(8) & (${MAXPAGESIZE} - 1))};}
	99	The current expression does not correctly handle the case of a
	100	text segment ending precisely at the end of a page; it causes the
	101	data segment to skip a page. The above expression does not have
	102	this problem, but it will currently (2/95) cause BFD to allocate
	103	a single segment, combining both text and data, for this case.
	104	This will prevent the text segment from being shared among
	105	multiple executions of the program; I think that is more
	106	important than losing a page of the virtual address space (note
	107	that no actual memory is lost; the page which is skipped can not
	108	be referenced). */
5f16938d	109	${RELOCATING+. = ${DATA_ADDR- ALIGN(8) + ${MAXPAGESIZE}};}
c2b6884b	110
5f16938d MM	111	.data ${RELOCATING-0} :
	112	{
	113	${RELOCATING+${DATA_START_SYMBOLS}}
	114	*(.data)
f5f212fb	115	(.gnu.linkonce.d)
5f16938d MM	116	${CONSTRUCTING+CONSTRUCTORS}
	117	}
	118	.data1 ${RELOCATING-0} : { *(.data1) }
	119	${RELOCATING+${OTHER_READWRITE_SECTIONS}}
5f16938d	120
4fe13b2b MM	121	.got1 ${RELOCATING-0} : { *(.got1) }
4fe13b2b MM	122	.dynamic ${RELOCATING-0} : { *(.dynamic) }
dd0f9635	123
86d0248d	124	/* Put .ctors and .dtors next to the .got2 section, so that the pointers
4fe13b2b MM	125	get relocated with -mrelocatable. Also put in the .fixup pointers.
4fe13b2b MM	126	The current compiler no longer needs this, but keep it around for 2.7.2 */
86d0248d	127
4d99a950	128	${RELOCATING+PROVIDE (_GOT2_START_ = .);}
4fe13b2b MM	129	.got2 ${RELOCATING-0} : { *(.got2) }
4fe13b2b MM	130
4d99a950	131	${RELOCATING+PROVIDE (__CTOR_LIST__ = .);}
4fe13b2b	132	.ctors ${RELOCATING-0} : { *(.ctors) }
4d99a950	133	${RELOCATING+PROVIDE (__CTOR_END__ = .);}
4fe13b2b	134
4d99a950	135	${RELOCATING+PROVIDE (__DTOR_LIST__ = .);}
4fe13b2b	136	.dtors ${RELOCATING-0} : { *(.dtors) }
4d99a950	137	${RELOCATING+PROVIDE (__DTOR_END__ = .);}
4fe13b2b	138
4d99a950	139	${RELOCATING+PROVIDE (_FIXUP_START_ = .);}
4fe13b2b	140	.fixup ${RELOCATING-0} : { *(.fixup) }
4d99a950 MM	141	${RELOCATING+PROVIDE (_FIXUP_END_ = .);}
4d99a950 MM	142	${RELOCATING+PROVIDE (_GOT2_END_ = .);}
4fe13b2b	143
4d99a950	144	${RELOCATING+PROVIDE (_GOT_START_ = .);}
4fe13b2b MM	145	.got ${RELOCATING-0} : { *(.got) }
4fe13b2b MM	146	.got.plt ${RELOCATING-0} : { *(.got.plt) }
c56c9218 C	147	${CREATE_SHLIB+${SDATA2}}
c56c9218 C	148	${CREATE_SHLIB+${SBSS2}}
4d99a950	149	${RELOCATING+PROVIDE (_GOT_END_ = .);}
1e4b4b1c	150
5f16938d MM	151	/* We want the small data sections together, so single-instruction offsets
	152	can access them all, and initialized data all before uninitialized, so
	153	we can shorten the on-disk segment size. */
4d99a950	154	.sdata ${RELOCATING-0} : { *(.sdata) }
5f16938d MM	155	${RELOCATING+_edata = .;}
5f16938d MM	156	${RELOCATING+PROVIDE (edata = .);}
7453a753 MM	157	.sbss ${RELOCATING-0} :
7453a753 MM	158	{
4d99a950	159	${RELOCATING+PROVIDE (__sbss_start = .);}
7453a753 MM	160	*(.sbss)
7453a753 MM	161	*(.scommon)
4d99a950	162	${RELOCATING+PROVIDE (__sbss_end = .);}
7453a753	163	}
4602e5f4	164	${PLT}
5f16938d MM	165	.bss ${RELOCATING-0} :
5f16938d MM	166	{
7453a753	167	${RELOCATING+${OTHER_BSS_SYMBOLS}}
4d99a950	168	${RELOCATING+PROVIDE (__bss_start = .);}
5f16938d MM	169	*(.dynbss)
	170	*(.bss)
	171	*(COMMON)
	172	}
	173	${RELOCATING+_end = . ;}
	174	${RELOCATING+PROVIDE (end = .);}
	175
	176	/* These are needed for ELF backends which have not yet been
	177	converted to the new style linker. */
	178	.stab 0 : { *(.stab) }
	179	.stabstr 0 : { *(.stabstr) }
	180
c2b6884b	181	/* DWARF debug sections.
264677bb JM	182	Symbols in the DWARF debugging sections are relative to the beginning
	183	of the section so we begin them at 0. */
	184
	185	/* DWARF 1 */
c2b6884b	186	.debug 0 : { *(.debug) }
264677bb JM	187	.line 0 : { *(.line) }
	188
	189	/* GNU DWARF 1 extensions */
	190	.debug_srcinfo 0 : { *(.debug_srcinfo) }
	191	.debug_sfnames 0 : { *(.debug_sfnames) }
	192
	193	/* DWARF 1.1 and DWARF 2 */
	194	.debug_aranges 0 : { *(.debug_aranges) }
	195	.debug_pubnames 0 : { *(.debug_pubnames) }
	196
	197	/* DWARF 2 */
9193c60b JM	198	.debug_info 0 : { *(.debug_info) }
	199	.debug_abbrev 0 : { *(.debug_abbrev) }
	200	.debug_line 0 : { *(.debug_line) }
	201	.debug_frame 0 : { *(.debug_frame) }
264677bb JM	202	.debug_str 0 : { *(.debug_str) }
	203	.debug_loc 0 : { *(.debug_loc) }
	204	.debug_macinfo 0 : { *(.debug_macinfo) }
	205
	206	/* SGI/MIPS DWARF 2 extensions */
	207	.debug_weaknames 0 : { *(.debug_weaknames) }
	208	.debug_funcnames 0 : { *(.debug_funcnames) }
	209	.debug_typenames 0 : { *(.debug_typenames) }
	210	.debug_varnames 0 : { *(.debug_varnames) }
c2b6884b	211
5f16938d MM	212	/* These must appear regardless of ${RELOCATING}. */
	213	${OTHER_SECTIONS}
	214	}
	215	EOF