1 /******************************************************************************
2 *
3 * Module Name: ahaslops - Table of all known ASL operators
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2014, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44 #include "acpihelp.h"
45
46 /*
47 * ASL operators with syntax (directly from ACPI specification).
48 * Note: All tokens require a space separator.
49 * Long lines are automatically split during output.
50 */
51 const AH_ASL_OPERATOR AslOperatorInfo[] =
52 {
53 {"AccessAs", "(AccessType, AccessAttribKeyword | "
54 "ExtendedAttribKeyword (AccessLength))",
55 "ChangeFieldUnitAccess"},
56 {"Acquire", "(SyncObject, TimeoutValue) => Boolean",
57 "Acquire a mutex"},
58 {"Add", "(Addend1, Addend2, Result) => Integer",
59 "Integer Add"},
60 {"Alias", "(SourceObject, AliasObject)",
61 "Define a name alias"},
62 {"And", "(Source1, Source2, Result) => Integer",
63 "Integer Bitwise And"},
64 {"Arg", "Arg0 - Arg6",
65 "Method argument data objects"},
66 {"BankField", "(RegionName, BankName, BankValue, "
67 "AccessTypeKeyword, LockRuleKeyword, "
68 "UpdateRuleKeyword) {FieldUnitList}",
69 "Declare fields in a banked configuration object"},
70 {"Break", "No parameters",
71 "Continue following the innermost enclosing While"},
72 {"BreakPoint", "No parameters",
73 "Used for debugging, stops execution in the debugger"},
74 {"Buffer", "(BufferSize) {String or ByteList} => Buffer",
75 "Declare Buffer object"},
76 {"Case", "(Value) {TermList}",
77 "Expression for conditional execution"},
78 {"Concatenate", "(Source1, Source2, Result) => ComputationalData",
79 "Concatenate two strings, integers or buffers"},
80 {"ConcatenateResTemplate", "(Source1, Source2, Result) => Buffer",
81 "Concatenate two resource templates"},
82 {"CondRefOf", "(Source, Result) => Boolean",
83 "Conditional reference to an object"},
84 {"Connection", "(ResourceMacro)",
85 "Associate connection with FieldUnits within a Field object"},
86 {"Continue", "No parameters",
87 "Continue innermost enclosing While loop"},
88 {"CopyObject", "(Source, Destination) => DataRefObject",
89 "Copy and existing object"},
90 {"CreateBitField", "(SourceBuffer, BitIndex, BitFieldName)",
91 "Declare a bit field object of a buffer object"},
92 {"CreateByteField", "(SourceBuffer, ByteIndex, ByteFieldName)",
93 "Declare a byte field object of a buffer object"},
94 {"CreateDWordField", "(SourceBuffer, ByteIndex, DWordFieldName)",
95 "Declare a DWord field object of a buffer object"},
96 {"CreateField", "(SourceBuffer, BitIndex, NumBits, FieldName)",
97 "Declare an arbitrary length bit field of a buffer object"},
98 {"CreateQWordField", "(SourceBuffer, ByteIndex, QWordFieldName)",
99 "Declare a QWord field object of a buffer object"},
100 {"CreateWordField", "(SourceBuffer, ByteIndex, WordFieldName)",
101 "Declare a Word field object of a buffer object"},
102 {"DataTableRegion", "(RegionName, SignatureString, OemIDString, OemTableIDString)",
103 "Declare a Data Table Region"},
104 {"Debug", "No parameters",
105 "Debugger output"},
106 {"Decrement", "(Minuend) => Integer",
107 "Decrement an Integer"},
108 {"Default", "{TermList}",
109 "Default execution path in Switch()"},
110 {"DefinitionBlock", "(AmlFileName, TableSignature, ComplianceRevision, "
111 "OemId, TableId, OemRevision) {TermList}",
112 "Declare a Definition Block"},
113 {"DerefOf", "(Source) => Object",
114 "Dereference an object reference"},
115 {"Device", "(DeviceName) {ObjectList}",
116 "Declare a bus/device object"},
117 {"Divide", "(Dividend, Divisor, Remainder, Result) => Integer",
118 "Integer Divide"},
119 {"DMA", "(DmaTypeKeyword, BusMasterKeyword, XferTypeKeyword, "
120 "DescriptorName) {DmaChannelList} => Buffer",
121 "DMA Resource Descriptor macro"},
122 {"DWordIO", "(ResourceTypeKeyword, MinKeyword, MaxKeyword, "
123 "DecodeKeyword, RangeTypeKeyword, AddressGranularity, "
124 "AddressMinimum, AddressMaximum, AddressTranslation, "
125 "RangeLength, ResourceSourceIndex, "
126 "ResourceSource, DescriptorName, TypeKeyword, TranslationKeyword)",
127 "DWord IO Resource Descriptor macro"},
128 {"DWordMemory", "(ResourceTypeKeyword, DecodeKeyword, MinKeyword, "
129 "MaxKeyword, MemTypeKeyword, ReadWriteKeyword, "
130 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
131 "RangeLength, ResourceSourceIndex, ResourceSource, DescriptorName, AddressKeyword, "
132 "TypeKeyword)",
133 "DWord Memory Resource Descriptor macro"},
134 {"DWordSpace", "(ResourceType, ResourceTypeKeyword, DecodeKeyword, "
135 "MinKeyword, MaxKeyword, TypeSpecificFlags, "
136 "AddressGranularity, AddressMinimum, AddressMaximum, "
137 "AddressTranslation, RangeLength, "
138 "ResourceSourceIndex, ResourceSource, DescriptorName)",
139 "DWord Space Resource Descriptor macro"},
140 {"EISAID", "(EisaIdString) => DWordConst",
141 "EISA ID String to Integer conversion macro"},
142 {"Else", "{TermList}",
143 "Alternate conditional execution"},
144 {"ElseIf", "(Predicate)",
145 "Conditional execution"},
146 {"EndDependentFn", "() => Buffer",
147 "End Dependent Function Resource Descriptor macro"},
148 {"Event", "(EventName)",
149 "Declare an event synchronization object"},
150 {"ExtendedIO", "(ResourceTypeKeyword, MinKeyword, MaxKeyword, "
151 "DecodeKeyword, RangeTypeKeyword, AddressGranularity, "
152 "AddressMinimum, AddressMaximum, AddressTranslation, RangeLength, "
153 "TypeSpecificAttributes, DescriptorName, TypeKeyword, TranslationKeyword)",
154 "Extended IO Resource Descriptor macro"},
155 {"ExtendedMemory", "(ResourceTypeKeyword, DecodeKeyword, MinKeyword, "
156 "MaxKeyword, MemTypeKeyword, ReadWriteKeyword, "
157 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
158 "RangeLength, TypeSpecificAttributes, DescriptorName, "
159 "AddressKeyword, TypeKeyword)",
160 "Extended Memory Resource Descriptor macro"},
161 {"ExtendedSpace", "(ResourceType, ResourceTypeKeyword, DecodeKeyword, "
162 "MinKeyword, MaxKeyword, TypeSpecificFlags, "
163 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
164 "RangeLength, TypeSpecificAttributes, DescriptorName)",
165 "Extended Space Resource Descriptor macro"},
166 {"External", "(ObjectName, ObjectTypeKeyword, ReturnType, ParameterTypes)",
167 "Declare external objects"},
168 {"Fatal", "(Type, Code, Arg)",
169 "Fatal error check"},
170 {"Field", "(RegionName, AccessTypeKeyword, LockRuleKeyword, "
171 "UpdateRuleKeyword) {FieldUnitList}",
172 "Declare fields of an operation region object"},
173 {"FindSetLeftBit", "(Source, Result) => Integer",
174 "Index of first least significant bit set"},
175 {"FindSetRightBit", "(Source, Result) => Integer",
176 "Index of first most significant bit set"},
177 {"FixedDMA", "(DmaRequestLine, Channel, TransferWidthKeyword, DescriptorName) => Buffer",
178 "Fixed DMA Resource Descriptor macro"},
179 {"FixedIO", "(AddressBase, RangeLength, DescriptorName) => Buffer",
180 "Fixed I/O Resource Descriptor macro"},
181 {"FromBCD", "(BCDValue, Result) => Integer",
182 "Convert from BCD to numeric"},
183 {"Function", "(FunctionName, ReturnType, ParameterTypes) {TermList}",
184 "Declare control method"},
185 {"GpioInt", "(InterruptTypeKeyword, InterruptLevelKeyword, "
186 "ShareTypeKeyword, PinConfigKeyword, "
187 "DebounceTimeout, ResourceSource, "
188 "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, "
189 "RawDataBuffer() {VendorData}) {Pin}",
190 "GPIO Interrupt Connection Resource Descriptor Macro"},
191 {"GpioIo", "(ShareTypeKeyword, PinConfigKeyword, DebounceTimeout, DriveStrength, "
192 "IoRestrictionKeyword, ResourceSource, "
193 "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, "
194 "RawDataBuffer() {VendorData}) {PinList}",
195 "GPIO I/O Connection Resource Descriptor Macro"},
196 {"I2cSerialBus", "(SlaveAddress, SlaveModeKeyword, ConnectionSpeed, "
197 "AddressingModeKeyword, ResourceSource, "
198 "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, "
199 "RawDataBuffer() {VendorData})",
200 "I2C Serial Bus Connection Resource Descriptor Macro"},
201 {"If", "(Predicate) {TermList}",
202 "Conditional execution"},
203 {"Include", "(FilePathName)",
204 "Include another ASL file"},
205 {"Increment", "(Addend) => Integer",
206 "Increment a Integer"},
207 {"Index", "(Source, Index, Destination) => ObjectReference",
208 "Indexed Reference to member object"},
209 {"IndexField", "(IndexName, DataName, AccessTypeKeyword, LockRuleKeyword, "
210 "UpdateRuleKeyword) {FieldUnitList}",
211 "Declare Index/Data Fields"},
212 {"Interrupt", "(ResourceTypeKeyword, InterruptTypeKeyword, InterruptLevelKeyword, "
213 "ShareTypeKeyword, ResourceSourceIndex, "
214 "ResourceSource, DescriptorName) {InterruptList} => Buffer",
215 "Interrupt Resource Descriptor macro"},
216 {"IO", "(IoDecodeKeyword, AddressMin, AddressMax, AddressAlignment, "
217 "RangeLength, DescriptorName) => Buffer",
218 "IO Resource Descriptor macro"},
219 {"IRQ", "(InterruptTypeKeyword, InterruptLevelKeyword, ShareTypeKeyword, "
220 "DescriptorName) {InterruptList} => Buffer",
221 "Interrupt Resource Descriptor macro"},
222 {"IRQNoFlags", "(DescriptorName) {InterruptList} => Buffer",
223 "Short Interrupt Resource Descriptor macro"},
224 {"LAnd", "(Source1, Source2) => Boolean",
225 "Logical And"},
226 {"LEqual", "(Source1, Source2) => Boolean",
227 "Logical Equal"},
228 {"LGreater", "(Source1, Source2) => Boolean",
229 "Logical Greater"},
230 {"LGreaterEqual", "(Source1, Source2) => Boolean",
231 "Logical Not less"},
232 {"LLess", "(Source1, Source2) => Boolean",
233 "Logical Less"},
234 {"LLessEqual", "(Source1, Source2) => Boolean",
235 "Logical Not greater"},
236 {"LNot", "(Source) => Boolean",
237 "Logical Not"},
238 {"LNotEqual", "(Source1, Source2) => Boolean",
239 "Logical Not equal"},
240 {"Load", "(Object, DDBHandle)",
241 "Load differentiating definition block"},
242 {"LoadTable", "(SignatureString, OemIdString, OemTableIdString, RootPathString, "
243 "ParameterPathString, ParameterData) => DDBHandle",
244 "Load Table from RSDT/XSDT"},
245 {"Local", "Local0 - Local7",
246 "Method local data objects"},
247 {"LOr", "(Source1, Source2) => Boolean",
248 "Logical Or"},
249 {"Match", "(SearchPackage, MatchOpKeyword, MatchObject1, MatchOpKeyword, "
250 "MatchObject2, StartIndex) => Ones | Integer",
251 "Search for match in package array"},
252 {"Memory24", "(ReadWriteKeyword, AddressMinimum, AddressMaximum, AddressAlignment, "
253 "RangeLength, DescriptorName)",
254 "Memory Resource Descriptor macro"},
255 {"Memory32", "(ReadWriteKeyword, AddressMinimum, AddressMaximum, AddressAlignment, "
256 "RangeLength, DescriptorName)",
257 "Memory Resource Descriptor macro"},
258 {"Memory32Fixed", "(ReadWriteKeyword, AddressBase, RangeLength, DescriptorName)",
259 "Memory Resource Descriptor macro"},
260 {"Method", "(MethodName, NumArgs, SerializeRuleKeyword, "
261 "SyncLevel, ReturnType, ParameterTypes) "
262 "{TermList}",
263 "Declare a control method"},
264 {"Mid", "(Source, Index, Length, Result) => Buffer or String",
265 "Return a portion of buffer or string"},
266 {"Mod", "(Dividend, Divisor, Result) => Integer",
267 "Integer Modulo"},
268 {"Multiply", "(Multiplicand, Multiplier, Result) => Integer",
269 "Integer Multiply"},
270 {"Mutex", "(MutexName, SyncLevel)",
271 "Declare a mutex synchronization object"},
272 {"Name", "(ObjectName, Object)",
273 "Declare a Named object"},
274 {"NAnd", "(Source1, Source2, Result) => Integer",
275 "Integer Bitwise Nand"},
276 {"NoOp", "No parameters",
277 "No operation"},
278 {"NOr", "(Source1, Source2, Result) => Integer",
279 "Integer Bitwise Nor"},
280 {"Not", "(Source, Result) => Integer",
281 "Integer Bitwise Not"},
282 {"Notify", "(Object, NotificationValue)",
283 "Notify Object of event"},
284 {"ObjectType", "(Object) => Integer",
285 "Type of object"},
286 {"Offset", "(ByteOffset)",
287 "Change Current Field Unit Offset"},
288 {"One", "=> Integer",
289 "Constant One Object (1)"},
290 {"Ones", "=> Integer",
291 "Constant Ones Object (0xFFFFFFFF or 0xFFFFFFFFFFFFFFFF)"},
292 {"OperationRegion", "(RegionName, RegionSpaceKeyword, Offset, Length)",
293 "Declare an operational region"},
294 {"Or", "(Source1, Source2, Result) => Integer",
295 "Integer Bitwise Or"},
296 {"Package", "(NumElements) {PackageList} => Package",
297 "Declare a package object"},
298 {"PowerResource", "(ResourceName, SystemLevel, ResourceOrder) {ObjectList}",
299 "Declare a power resource object"},
300 {"Processor", "(ProcessorName, ProcessorID, PBlockAddress, PblockLength) {ObjectList}",
301 "Declare a processor package"},
302 {"QWordIO", "(ResourceTypeKeyword, MinKeyword, MaxKeyword, DecodeKeyword, "
303 "RangeTypeKeyword, AddressGranularity, "
304 "AddressMinimum, AddressMaximum, AddressTranslation, RangeLength, "
305 "ResourceSourceIndex, ResourceSource, DescriptorName, TypeKeyword, "
306 "TranslationKeyword)",
307 "QWord IO Resource Descriptor macro"},
308 {"QWordMemory", "(ResourceTypeKeyword, DecodeKeyword, MinKeyword, MaxKeyword, "
309 "MemTypeKeyword, ReadWriteKeyword, "
310 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
311 "RangeLength, ResourceSourceIndex, ResourceSource, "
312 "DescriptorName, AddressKeyword, "
313 "TypeKeyword)",
314 "QWord Memory Resource Descriptor macro"},
315 {"QWordSpace", "(ResourceType, ResourceTypeKeyword, DecodeKeyword, "
316 "MinKeyword, MaxKeyword, TypeSpecificFlags, "
317 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
318 "RangeLength, ResourceSourceIndex, ResourceSource, DescriptorName)",
319 "Qword Space Resource Descriptor macro"},
320 {"RawDataBuffer", "(BufferSize) {ByteList} => RawDataBuffer",
321 "Create a raw data buffer (does not use Buffer AML opcode)"},
322 {"RefOf", "(Object) => ObjectReference",
323 "Create Reference to an object"},
324 {"Register", "(AddressSpaceKeyword, RegisterBitWidth, "
325 "RegisterBitOffset, RegisterAddress, "
326 "AccessSize, DescriptorName)",
327 "Generic register Resource Descriptor macro"},
328 {"Release", "(SyncObject)",
329 "Release a synchronization object"},
330 {"Reset", "(SyncObject)",
331 "Reset a synchronization object"},
332 {"ResourceTemplate", "() {ResourceMacroList} => Buffer",
333 "Resource to buffer conversion macro"},
334 {"Return", "None | () | (ReturnArg)",
335 "Return from method execution"},
336 {"Revision", "=> Integer",
337 "Constant revision object"},
338 {"Scope", "(Location) {ObjectList}",
339 "Open named scope "},
340 {"ShiftLeft", "(Source, ShiftCount, Result) => Integer",
341 "Integer shift value left"},
342 {"ShiftRight", "(Source, ShiftCount, Result) => Integer",
343 "Integer shift value right"},
344 {"Signal", "(SyncObject)",
345 "Signal a synchronization object"},
346 {"SizeOf", "(ObjectName) => Integer",
347 "Get the size of a buffer}, string}, or package"},
348 {"Sleep", "(Milliseconds)",
349 "Sleep n milliseconds (yields the processor)"},
350 {"SpiSerialBus", "(DeviceSelection, PolarityKeyword, WireModeKeyword, "
351 "DataBitLength, SlaveModeKeyword, "
352 "ConnectionSpeed, ClockPolarityKeyword, ClockPhaseKeyword, "
353 "ResourceSource, ResourceSourceIndex, "
354 "ResourceTypeKeyword, DescriptorName, RawDataBuffer() {VendorData})",
355 "SPI Serial Bus Connection Resource Descriptor Macro"},
356 {"Stall", "(Microseconds)",
357 "Delay n microseconds (does not yield the processor)"},
358 {"StartDependentFn", "(CompatibilityPriority, PerformancePriority) {ResourceList}",
359 "Start Dependent Function Resource Descriptor macro"},
360 {"StartDependentFnNoPri", "() {ResourceList}",
361 "Start Dependent Function Resource Descriptor macro"},
362 {"Store", "(Source, Destination) => DataRefObject",
363 "Store object"},
364 {"Subtract", "(Minuend, Subtrahend, Result) => Integer",
365 "Integer Subtract"},
366 {"Switch", "(Expression) {CaseTermList}",
367 "Select code to execute based on expression value"},
368 {"ThermalZone", "(ThermalZoneName) {ObjectList}",
369 "Declare a thermal zone package"},
370 {"Timer", "=> Integer",
371 "Get 64-bit timer value"},
372 {"ToBCD", "(Value, Result) => Integer",
373 "Convert Integer to BCD"},
374 {"ToBuffer", "(Data, Result) => Buffer",
375 "Convert data type to buffer"},
376 {"ToDecimalString", "(Data, Result) => String",
377 "Convert data type to decimal string"},
378 {"ToHexString", "(Data, Result) => String",
379 "Convert data type to hexadecimal string"},
380 {"ToInteger", "(Data, Result) => Integer",
381 "Convert data type to integer"},
382 {"ToString", "(Source, Length, Result) => String",
383 "Copy ASCII string from buffer"},
384 {"ToUUID", "(AsciiString) => Buffer",
385 "Convert Ascii string to UUID"},
386 {"UartSerialBus", "(ConnectionSpeed, ByteLengthKeyword, StopBitsKeyword, "
387 "LinesInUse, EndianKeyword, ParityKeyword, "
388 "FlowControlKeyword, ReceiveBufferSize, TransmitBufferSize, ResourceSource, "
389 "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, "
390 "RawDataBuffer() {VendorData})",
391 "UART Serial Bus Connection Resource Descriptor Macro"},
392 {"Unicode", "(String) => Buffer",
393 "String to Unicode conversion macro"},
394 {"Unload", "(Handle)",
395 "Unload definition block"},
396 {"VendorLong", "(DescriptorName) {VendorByteList}",
397 "Vendor Resource Descriptor"},
398 {"VendorShort", "(DescriptorName) {VendorByteList}",
399 "Vendor Resource Descriptor"},
400 {"Wait", "(SyncObject, TimeoutValue) => Boolean",
401 "Wait on an Event"},
402 {"While", "(Predicate) {TermList}",
403 "Conditional loop"},
404 {"WordBusNumber", "(ResourceTypeKeyword, MinKeyword, MaxKeyword, DecodeKeyword, "
405 "AddressGranularity, AddressMinimum, "
406 "AddressMaximum, AddressTranslation, RangeLength, ResourceSourceIndex, "
407 "ResourceSource, DescriptorName)",
408 "Word Bus number Resource Descriptor macro"},
409 {"WordIO", "(ResourceTypeKeyword, MinKeyword, MaxKeyword, DecodeKeyword, "
410 "RangeTypeKeyword, AddressGranularity, "
411 "AddressMinimum, AddressMaximum, AddressTranslation, RangeLength, "
412 "ResourceSourceIndex, ResourceSource, DescriptorName, TypeKeyword, "
413 "TranslationKeyword)",
414 "Word IO Resource Descriptor macro"},
415 {"WordSpace", "(ResourceType, ResourceTypeKeyword, DecodeKeyword, MinKeyword, "
416 "MaxKeyword, TypeSpecificFlags, "
417 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
418 "RangeLength, ResourceSourceIndex, ResourceSource, DescriptorName)",
419 "Word Space Resource Descriptor macro"},
420 {"XOr", "(Source1, Source2, Result) => Integer",
421 "Integer Bitwise Xor"},
422 {"Zero", "=> Integer",
423 "Constant Zero object (0)"},
424 {NULL, NULL, NULL}
425 };