<?xml version='1.0' encoding='utf-8' standalone='no' ?>
<!--

  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

-->
<AS2LintWarnings>

<!-- ***Dont use ?? in these - use ? if you must; C++ translates ?? into a ^ symbol for some reason..***
   
  

   In addition, the following words should not be translated:
	AS2
	AS3
	SWF
	Class
	class
	namespace
	Namespace
	
	TODO:  XML 
-->
	
<warnings>
	<warning id="1008" hidden="true" label="kWarning_NoTypeDecl">Chybí deklarace typu.</warning>
	<warning id="1009" label="kWarning_NoTypeDecl_specific">%s '%s' nemá žádnou deklaraci typu.
	
	<description>
		<![CDATA[
		Not declaring a data type is a coding style preference.  A function return type, parameter, or variable has no type declaration.  
		However, using type declarations enables the compiler to write more efficient code, as well as detect more errors at compile time.
		Enable this warning if you want to be reminded when you fail to use a type declaration.
		]]>
	</description></warning>
	<warning id="1012" hidden="true" label="kWarning_BadUndefinedComparision">Nelogické porovnání s nedefinovanou proměnnou. Pouze proměnné bez typu (nebo proměnné typu *) mohou být nedefinované.</warning>
	<warning id="1013" label="kWarning_BadUndefinedComparision_specific">Proměnné typu %s nemohou být nedefinované. U nedefinované hodnoty bude před porovnáním vynuceně nastaven typ %s.
	<description>
		<![CDATA[
	Only variables of type * can be undefined.  With a few exceptions, uninitialized variables have a default value of <code>null</code> rather than <code>undefined</code>.  
	The exceptions include: Boolean variables, which have a default value of <code>false</code>. Number variables, which have a default value of <code>NaN</code>, and int or uint variables, which have a default value of <code>0</code>.
			]]>
	</description>
	</warning>
	
	<warning id="1030" hidden="true" label="kWarning_ConstructorReturnsValue">Funkce použitá v novém výrazu vrací hodnotu. Výsledkem bude to, co tato funkce vrací, nikoli nová instance této funkce.</warning>
	<warning id="1031" label="kWarning_ConstructorReturnsValue_specific">Problém při přesunutí: Výsledkem nové položky %s bude vrácená hodnota %s, nikoli nová instance této funkce.
	<description>
		<![CDATA[
		This is a code migration warning.  The detected code behaves differently in ActionScript 3.0 than in ActionScript 2.0, as shown in the following example:
<pre><code>function f(){
   this.b = 22;
   this.a = new Array(2);  
   this.a[0] = 33;
   this.a[1] = 44;
   return a; 
   } 
   // returns a new instance of f in ActionScript 2.0 and a new 2 element array in ActionScript 3.0
   var d = new f();  // Warning here
   trace(d.a);       // undefined in ActionScript 3.0, [33,44] in ActionScript 2.0.
</code></pre>
]]>
</description>	
	</warning>

	<warning id="1034" hidden="true" label="kWarning_BooleanConstructorWithNoArgs">Funkce Boolean() bez argumentů vrací hodnotu false v ActionScriptu 3.0. Funkce Boolean() vracela hodnotu undefined v ActionScriptu 2.0.</warning>
	<warning id="1035" label="kWarning_BooleanConstructorWithNoArgs_specific">Použití funkce Boolean() bez argumentů.
	<description>
		<![CDATA[
		This is a code migration warning.  The <code>Boolean()</code> function returns <code>false</code> in ActionScript 3.0, but <code>undefined</code> in ActionScript 2.0.
		]]>
	</description>
	</warning>
	
	<warning id="1038" hidden="true" label="kWarning_NumberFromStringChanges">V ActionScriptu 3.0 se prázdná místa (mezery) ignorují a parametr '' vrací se hodnota 0. V ActionScriptu 2.0 vrací funkce Number() hodnotu NaN (Not a Number), pokud má parametr hodnotu '' nebo obsahuje prázdná místa (mezery).</warning>
	<warning id="1039" label="kWarning_NumberFromStringChanges_specific">Problém při přesunutí: Pokud je funkce Number('') volána s argumentem s prázdným řetězcem, vrátí hodnotu 0 v ActionScriptu 3.0 a hodnotu NaN v ActionScriptu 2.0.
	<description>
		<![CDATA[
		This is a code migration warning.  The <code>Number()</code> method called with a String argument skips over all white space in the string and return a default value of 0 if no digits are detected.
In ActionScript 2.0, any white space in the string causes the result to be NaN.
		]]>
	</description>
	</warning>

	<warning id="1044" hidden="true" label="kWarning_ArrayToStringChanges">Formát Array.toString() se změnil.</warning>
	<warning id="1045" label="kWarning_ArrayToStringChanges_specific">Problém při přesunutí: Způsob zpracování nulových a nedefinovaných prvků ve formátu Array.toString() se změnil.
	<description>
		<![CDATA[
		This is a code migration warning.  In ActionScript 2.0, <code>null</code> array elements convert to <code>null</code> and <code>undefined</code> elements convert to <code>undefined</code>.  
In ActionScript 3.0, both <code>null</code> and <code>undefined</code> elements convert to the empty string ''.  If you have code that parses the <code>toString()</code> output from an Array,
you may need to adjust your code for this difference.
		]]>
	</description>
	</warning>
	
	<warning id="1058" hidden="true" label="kWarning_DepricatedPropertyError">Nepodporovaná vlastnost ActionScriptu 2.0.</warning>
	<warning id="1059" label="kWarning_DepricatedPropertyError_specific">Problém při přesunutí: Vlastnost %s již není podporována.  %s.
	<description>
		<![CDATA[
		This is a code migration warning.  The property you are attempting to use does not exist in ActionScript 3.0.
				]]>
	</description>
	</warning>

	<warning id="1060" hidden="true" label="kWarning_DepricatedFunctionError">Nepodporovaná funkce ActionScriptu 2.0.</warning>
	<warning id="1061" label="kWarning_DepricatedFunctionError_specific">Problém při přesunutí: Metoda %s již není podporována.  %s.
	<description>
		<![CDATA[
		This is a code migration warning.  The method you are attempting to use does not exist in ActionScript 3.0.
		]]>
	</description>
	</warning>
	
	<warning id="1066" label="kWarning_ChangesInResolve">Funkce __resolve již není podporována.</warning>
	<warning id="1067" label="kWarning_ChangesInResolve_specific">Problém při přesunutí: Funkce __resolve již není podporována. Pro podobné funkce používejte novou třídu Proxy.
	<description>
		<![CDATA[
		This is a code migration warning.  See Proxy in this language reference for more information on the replacement for <code>__resolve</code>.
		]]>
	</description>
	</warning>
	<warning id="1070" hidden="true" label="kWarning_LevelNotSupported">Funkce __level již není podporována. Další informace naleznete v balíčku flash.display.</warning>
	<warning id="1071" label="kWarning_LevelNotSupported_specific">Problém při přesunutí: Funkce __level již není podporována. Další informace naleznete v balíčku flash.display.
	<description>
		<![CDATA[
		This is a code migration warning.  The property you are attempting to use does not exist in ActionScript 3.0.
		]]>
	</description>
	</warning>
	
	<warning id="1072" hidden="true" label="kWarning_ClassIsSealed">Třída je uzavřená. Nelze k ní dynamicky přidávat členy.</warning>
	<warning id="1073" label="kWarning_ClassIsSealed_specific">Problém při přesunutí: %s nepředstavuje dynamickou třídu. K instancím nelze dynamicky přidávat členy.
	<description>
		<![CDATA[
		This is a code migration warning.  In ActionScript 2.0, many classes such as Number are dynamic, which means that new properties can
be added to instances of those classes at run time.  This warning results from code that tries to add a property to an instance of a non-dynamic class.
		]]>
	</description>
	</warning>
	<warning id="1082" hidden="true" label="kWarning_ScopingChangeInThis">Změna rozsahu platnosti pro klíčové slovo this. V metodách třídy získaných z instance třídy bude this vždy odkazovat na tuto instanci. V ActionScriptu 2.0 se this vyhledává dynamicky na základě toho, odkud se metoda vyvolá.</warning>
	<warning id="1083" label="kWarning_ScopingChangeInThis_specific">Problém při přesunutí: Metoda %s se bude chovat jinak v ActionScriptu 3.0 z důvodu změny v rozsahu platnosti pro klíčové slovo this. Další informace naleznete u položky pro upozornění 1083.
<description>
		<![CDATA[
		This is a code migration warning.  This warning is generated when a method of an object is used as a value, usually as a callback function.
		In ActionScript 2.0, functions are executed in the context they are called from.  In ActionScript 3.0, functions are always
		executed in the context where they were defined.  Thus, variable and method names are resolved to the class that the callback is part of, rather
		than relative to the context it is called from, as in the following example:
		
<pre><code>class a 
{ 
   var x; 
   function a() { x = 1; } 
   function b() { trace(x); } 
}

var A:a = new a();
var f:Function = a.b; // warning triggered here
var x = 22;
f(); // prints 1 in ActionScript 3.0, 22 in ActionScript 2.0</code></pre>		]]>
	</description>
	</warning>
	
	<warning id="1084" hidden="true" label="kWarning_MissingNamespaceDecl">Chybí deklarace prostoru názvů (např. proměnná není definovaná jako public, private atd.).</warning>
	<warning id="1085" label="kWarning_MissingNamespaceDecl_specific">Rozsah platnosti položky %s bude nastaven na výchozí prostor názvů: %s interní. Položka nebude viditelná mimo tento balíček.
<description>
	<![CDATA[
	Not declaring a namespace is a coding style preference.  Enable this warning if you want to be reminded when you forget to declare a namespace or access specifier for a definition.
	Without one, the definition is not visible to code located outside of this file.  To make it visible to code outside this file, declare it with the access specifier <code>public</code> or with
	a namespace declaration.  To keep the definition local to this file and avoid this warning, declare the definition as <code>private</code>.
	]]>
</description>
	</warning>

	<warning id="1086" hidden="true" label="kWarning_ForVarInChanges">ActionScript 3.0 iteruje přes vlastnosti objektu uvnitř příkazu "for x in target" v náhodném pořadí.</warning>
	<warning id="1087" label="kWarning_ForVarInChanges_specific">Problém při přesunutí: ActionScript 3.0 iteruje přes vlastnosti objektu uvnitř příkazu "for x in target" v náhodném pořadí.
	<description>
		<![CDATA[
		This is a code migration warning.  In ActionScript 2.0, the order in which the properties of an object were processed was always the same.  
In ActionScript 3.0, the order is random and can change from machine to machine.  If unexpected ordering behavior occurs, inspect this loop to determine if this change in behavior may affect your code.
		]]>
	</description>
	</warning>
	
	<warning id="1088" hidden="true" label="kWarning_InternalError">Interní chyba v kompilátoru.</warning>
	<warning id="1089" label="kWarning_InternalError_specific">Kód chyby: %s.
	<description>
		<![CDATA[
		This is due to either a corrupt source file or a bug in the compiler code.  Please contact the Apache Software Foundation to file a bug.
		]]>
	</description>
	</warning>
	<warning id="1090" hidden="true" label="kWarning_DepricatedEventHandlerError">EventHandler nebyl přidán jako posluchač.</warning>
	<warning id="1091" label="kWarning_DepricatedEventHandlerError_specific">Problém při přesunutí: %s
	<description>
		<![CDATA[
		This is a code migration warning.  In ActionScript 2.0 declaring a method by a special name (such as <code>onMouseDown</code>) would cause Flash to
call that method when a certain event occurred.  In ActionScript 3.0, you must call <code>addEventListener()</code> with a method in order to register it to 
receive that event.  See <code>addEventListener</code> in this language reference for details.
		]]>
	</description>
	</warning>
	
    <warning id="1092" hidden="true" label="kWarning_NegativeUintLiteral">Záporná hodnota se při přiřazení k typu dat uint změní na velkou kladnou hodnotu.</warning>
    <warning id="1093" label="kWarning_NegativeUintLiteral_specific">Záporná hodnota byla použita na místě, kde je očekávána hodnota uint (nezáporná).
	<description>
		<![CDATA[
		Assigning a negative value to a uint data type results in an extremely large positive value. <code>var x:uint = -1;  trace(x); // 4294967295</code>.
		]]>
	</description>
	</warning>
	
	<warning id="1096" hidden="true" label="kWarning_BadNullComparision">Nelogické porovnání s null.</warning>
	<warning id="1097" label="kWarning_BadNullComparision_specific">Nelogické porovnání s null. Proměnné typu %s nemohou mít hodnotu null.
	<description>
		<![CDATA[
		Instances of Boolean, int, uint, and Number cannot be <code>null</code>.  The comparison operator type converts <code>null</code> to <code>false</code> before
comparing it to a Boolean, or to 0 before comparing it with a Number, int, or uint data type.
		]]>
	</description>
    </warning>
	<warning id="1098" hidden="true" label="kWarning_BadNaNComparision">Nelogické porovnání s NaN (Not a Number). Jakákoli operace porovnání zahrnující hodnotu NaN se vyhodnotí jako nepravdivá, protože NaN != NaN.</warning>
	<warning id="1099" label="kWarning_BadNaNComparision_specific">Nelogické porovnání s NaN (Not a Number). Tento příkaz se vždy vyhodnocuje jako nepravdivý.
	<description>
		<![CDATA[
		<code>NaN</code> has the unique mathematical property that any comparison involving it evaluates to <code>false</code>.  Use the global <code>isNaN()</code> function to detect a NaN value instead, as in the following example:
<pre><code>trace(NaN == NaN); // false!
trace(NaN != NaN); // false again!
trace(isNaN(NaN)); // true
</code></pre>
]]></description>
	</warning>
	
	<warning id="1100" hidden="true" label="kWarning_AssignmentWithinConditional">Přiřazení uvnitř podmínky.</warning>
	<warning id="1101" label="kWarning_AssignmentWithinConditional_specific">Přiřazení uvnitř podmínky. Opravdu jste chtěli zadat == namísto =?

<description>
		<![CDATA[
		The result of an = assignment statement is the value of the right-hand side of the = statement.
	    You can use an assignment statement as a conditional test, but it is not recommended. 
	    It usually is the result of a typo where a == equality test was intended, as the following example shows: 
<pre><code>var x:Boolean = false;
var y:Boolean = true;
// it is hard to determine if the line below intentionally sets x's value to y's or if its a typo
if (x = y) { trace("x is assigned y's value of true, making the conditional test evaluate as true."); }
</code></pre>
]]></description>



</warning>
	<warning id="1102" hidden="true" label="kWarning_BadNullAssignment">Nemožné přiřazení hodnoty null.</warning>
	<warning id="1103" label="kWarning_BadNullAssignment_specific">Hodnota null byla použita na místě, kde byla očekávána hodnota %s. 
	<description>
		<![CDATA[
		Boolean, Number, int, and uint variables cannot be assigned <code>null</code> as a value. The <code>null</code> value is implicitly cast to <code>false</code> when assigned to a Boolean, and to <code>0</code> when assigned to an int, uint, or Number.
		]]>
	</description>
	</warning>
	<warning id="1104" hidden="true" label="kWarning_NoConstructor">Chybí konstruktor.</warning>
	<warning id="1105" label="kWarning_NoConstructor_specific">Pro třídu %s nebyla určena žádná funkce konstruktoru.
	<description>
		<![CDATA[
		Not specifying a constructor function is a coding style preference.  Enable this warning if you want to always declare constructors for classes.  
This warning is intended to help find cases where a class name is changed but its constructor's name is not.  
Conditions such as this are not flagged as a problem without this warning, the former constructor appears to be a normal function.
		]]>
	</description>
    </warning>
    
	<warning id="1110" hidden="true" label="kWarning_ConstNotInitialized">Konstanta není inicializovaná.</warning>
	<warning id="1111" label="kWarning_ConstNotInitialized_specific">Konstanta nebyla inicializovaná.</warning>
	<warning id="1112" hidden="true" label="kWarning_BadArrayCast">Možná neplatná operace přetypování pole.</warning>
	<warning id="1113" label="kWarning_BadArrayCast_specific">Funkce Array(x) se chová stejně jako nová funkce Array(x). Chcete-li přetypovat hodnotu na typ Pole, použijte jako pole výraz x namísto funkce Array(x).</warning>
	<warning id="1114" hidden="true" label="kWarning_NoExplicitSuperCallInConstructor">V konstruktoru nebyl volán příkaz super().</warning>
	<warning id="1115" label="kWarning_NoExplicitSuperCallInConstructor_specific">Příkaz super() bude proveden před vstupem do tohoto konstruktoru. Přidejte volání příkazu super() do konstruktoru, pokud chcete explicitně řídit, kdy bude proveden.
	<description>
		<![CDATA[
		Adding a call to <code>super()</code> within the constructor is a coding style preference.  Enable this warning if you want to always be explicit about when <code>super()</code> is called.
This can help catch cases where you meant to call <code>super()</code> after some local initialization code and forgot to add it.
		]]>
	</description></warning>

	<warning id="2090" hidden="true" label="kUnsupportedProp_version">Použijte vlastnost Capabilities.version.</warning>
	<warning id="2091" hidden="true" label="kUnsupportedProp_Focusrect">Další informace viz vlastnost InteractiveObject.focusRect.</warning>
	<warning id="2092" hidden="true" label="kUnsupportedProp_Highquality">Další informace viz vlastnost Stage.quality.</warning>
	<warning id="2093" hidden="true" label="kUnsupportedProp_DisplayObj_HighQuality">Další informace viz vlastnost Stage.quality.</warning>
	<warning id="2094" hidden="true" label="kUnsupportedProp_DisplayObj_Quality">Další informace viz vlastnost Stage.quality.</warning>
	<warning id="2095" hidden="true" label="kUnsupportedProp_Quality">Další informace viz vlastnost Stage.quality.</warning>
	<warning id="2096" hidden="true" label="kUnsupportedProp_TextField_Soundbuftime">Použijte místo toho statickou vlastnost flash.media.SoundMixer.bufferTime.</warning>
	<warning id="2097" hidden="true" label="kUnsupportedProp_TextField_Target">Tato funkce již není podporována.</warning>
	<warning id="2098" hidden="true" label="kUnsupportedProp_TextField_Url">Další informace viz vlastnost LoaderInfo.url.</warning>
	<warning id="2099" hidden="true" label="kUnsupportedProp_TextField_Variable">Tato funkce již není podporována.</warning>
	<warning id="2102" hidden="true" label="kUnsupportedProp_NewLine">Pro zadání nového řádku použijte '\n'.</warning>
	<warning id="2103" hidden="true" label="kUnsupportedProp_MaxScroll">Další informace viz vlastnost textField.maxScroll.</warning>
	<warning id="2104" hidden="true" label="kUnsupportedProp_Level">V ActionScriptu 3.0 neexistuje koncept úrovní. Místo něj je k dispozici přímý přístup k seznamu zobrazení. Podrobnosti naleznete v balíčku flash.display.</warning>
	<warning id="2105" hidden="true" label="kUnsupportedProp_Parent">Použijte místo toho rodičovskou vlastnost.</warning>
	<warning id="2106" hidden="true" label="kUnsupportedProp_Root">Tato vlastnost byla odstraněna. Nejbližším ekvivalentem je vlastnost Stage, která slouží jako kořen seznamu zobrazení v ActionScriptu 3.0.</warning>
	<warning id="2107" hidden="true" label="kUnsupportedProp_Arguments_Caller">Zkuste místo toho volající objekt deklarovat jako argument funkce.</warning>
	<warning id="2108" hidden="true" label="kUnsupportedProp_Button_Target">Tato funkce již není podporována.</warning>
	<warning id="2109" hidden="true" label="kUnsupportedProp_MovieClip_Parent">Použijte místo toho rodičovskou vlastnost.</warning>
	<warning id="2110" hidden="true" label="kUnsupportedProp_MovieClip_target">Tato funkce již není podporována.</warning>
	<warning id="2111" hidden="true" label="kUnsupportedProp_MovieClip_hitArea">Další informace viz vlastnost Sprite.hitArea.</warning>
	<warning id="2112" hidden="true" label="kUnsupportedProp_Scroll">Další informace viz vlastnosti scrollH a scrollV třídy flash.text.TextField.</warning>
	<warning id="2113" hidden="true" label="kUnsupportedProp_TargetPath">Namísto cest použijte objekty MovieClip přímo jako argumenty.</warning>
	<warning id="2114" hidden="true" label="kUnsupportedProp_Video_Height">Další informace viz vlastnost Video.videoHeight.</warning>
	<warning id="2115" hidden="true" label="kUnsupportedProp_Video_Width">Další informace viz vlastnost Video.videoWidth.</warning>
	<warning id="2116" hidden="true" label="kUnsupportedProp__Proto__">Další informace viz zastaralá vlastnost __proto__.</warning>
	<warning id="2117" hidden="true" label="kUnsupportedProp_Stage">Další informace viz vlastnost DisplayObject.stage.</warning>
	<warning id="2118" hidden="true" label="kUnsupportedProp__remoteClass">Použijte místo toho metodu registerClass() v balíčku flash.net.</warning>
	<warning id="2617" hidden="true" label="kUnsupportedMeth_random">Použijte místo toho metodu Math.random().</warning>
	<warning id="2618" hidden="true" label="kUnsupportedMeth_chr">Použijte místo toho metodu String.fromCharCode().</warning>
	<warning id="2619" hidden="true" label="kUnsupportedMeth_mbchr">Použijte místo toho metodu String.fromCharCode().</warning>
	<warning id="2621" hidden="true" label="kUnsupportedMeth_ord">Použijte místo toho metodu String.charCodeAt().</warning>
	<warning id="2622" hidden="true" label="kUnsupportedMeth_mbord">Použijte místo toho metodu String.charCodeAt().</warning>
	<warning id="2623" hidden="true" label="kUnsupportedMeth_substring">Použijte místo toho vlastnost String.substr.</warning>
	<warning id="2624" hidden="true" label="kUnsupportedMeth_mbsubstring">Použijte místo toho vlastnost String.substr.</warning>
	<warning id="2625" hidden="true" label="kUnsupportedMeth_length">Použijte místo toho vlastnost length argumentu.</warning>
	<warning id="2626" hidden="true" label="kUnsupportedMeth_mblength">Použijte místo toho vlastnost length argumentu.</warning>
	<warning id="2627" hidden="true" label="kUnsupportedMeth_ASNative">Další informace viz změny funkce ASnative.</warning>
	<warning id="2628" hidden="true" label="kUnsupportedMeth_addProperty">Místo toho nastavte vlastnosti přímo u instance pomocí tečkového (.) zápisu.</warning>
	<warning id="2629" hidden="true" label="kUnsupportedMeth_getProperty">Místo toho získejte k vlastnostem přístup přímo pomocí tečkového (.) zápisu.</warning>
	<warning id="2630" hidden="true" label="kUnsupportedMeth_setProperty">Místo toho nastavte vlastnosti přímo u instance pomocí tečkového (.) zápisu.</warning>
	<warning id="2631" hidden="true" label="kUnsupportedMeth_asfunction">Další informace viz vlastnosti TextEvent.LINK a addEventListener().</warning>
	<warning id="2633" hidden="true" label="kUnsupportedMeth_clearInterval">Tato metoda se přesunula do balíčku flash.utils.</warning>
	<warning id="2634" hidden="true" label="kUnsupportedMeth_duplicateMovieClip">Nahrazeno novou funkcí konstruktoru tříd MovieClip.</warning>
	<warning id="2636" hidden="true" label="kUnsupportedMeth_fscommand">Přesunuto do balíčku flash.system. Viz také třída flash.external.ExternalInterface pro komunikaci Javascript/ActionScript.</warning>
	<warning id="2638" hidden="true" label="kUnsupportedMeth_getURL">Informace o ekvivalentních funkcích viz funkce flash.net.URLLoader. Balíček flash.net obsahuje také funkce na úrovni balíčku navigateToURL() a sendToURL().</warning>
	<warning id="2639" hidden="true" label="kUnsupportedMeth_gotoAndPlay">Další informace viz metoda MovieClip.gotoAndPlay().</warning>
	<warning id="2640" hidden="true" label="kUnsupportedMeth_gotoAndStop">Další informace viz metoda MovieClip.gotoAndStop().</warning>
	<warning id="2641" hidden="true" label="kUnsupportedMeth_play">Další informace viz metoda MovieClip.play().</warning>
	<warning id="2642" hidden="true" label="kUnsupportedMeth_print">Další informace viz metoda PrintJob.start().</warning>
	<warning id="2643" hidden="true" label="kUnsupportedMeth_printAsBitmap">Další informace viz funkce PrintJob.</warning>
	<warning id="2644" hidden="true" label="kUnsupportedMeth_printAsBitmapNum">Další informace viz funkce PrintJob.</warning>
	<warning id="2645" hidden="true" label="kUnsupportedMeth_printNum">Další informace viz funkce PrintJob.</warning>
	<warning id="2646" hidden="true" label="kUnsupportedMeth_removeMovieClip">Použijte metodu Container.removeChild(childName). Další informace viz třída DisplayObjectContainer.</warning>
	<warning id="2647" hidden="true" label="kUnsupportedMeth_setInterval">Přesunuto do balíčku flash.utils. Místo toho zvažte použití třídy Timer.</warning>
	<warning id="2648" hidden="true" label="kUnsupportedMeth_nextFrame">Další informace viz metoda MovieClip.nextFrame().</warning>
	<warning id="2649" hidden="true" label="kUnsupportedMeth_startDrag">Další informace viz metoda MovieClip.startDrag().</warning>
	<warning id="2650" hidden="true" label="kUnsupportedMeth_stop">Další informace viz metoda MovieClip.stop().</warning>
	<warning id="2651" hidden="true" label="kUnsupportedMeth_stopAllSounds">Další informace viz metoda Sound.stopAllSounds().</warning>
	<warning id="2652" hidden="true" label="kUnsupportedMeth_stopDrag">Další informace viz metoda MovieClip.stopDrag().</warning>
	<warning id="2653" hidden="true" label="kUnsupportedMeth_tellTarget">Použijte místo toho tečkový (.) operátor nebo příkaz with.</warning>
	<warning id="2654" hidden="true" label="kUnsupportedMeth_toggleHighQuality">Další informace viz vlastnost DisplayObject.stage a Stage.quality.</warning>
	<warning id="2656" hidden="true" label="kUnsupportedMeth_unloadMovie">Použijte místo toho metodu DisplayObjectContainer.removeChild(childName). Další informace viz třída DisplayObjectContainer.</warning>
	<warning id="2657" hidden="true" label="kUnsupportedMeth_unloadMovieNum">Použijte místo toho metodu DisplayObjectContainer.removeChild(childName). Další informace viz třída DisplayObjectContainer.</warning>
	<warning id="2658" hidden="true" label="kUnsupportedMeth_updateAfterEvent">Tato funkce již není globální funkcí, avšak je stále k dispozici jako metoda tříd TimerEvent, MouseEvent a KeyboardEvent.</warning>
	<warning id="2659" hidden="true" label="kUnsupportedMeth_Video_attachVideo">Další informace viz funkce Video.attachNetStream a Video.attachCamera.</warning>
	<warning id="2660" hidden="true" label="kUnsupportedMeth_TextField_StyleSheet_load">Pomocí třídy URLLoader proveďte načítání a výsledek předejte do metody StyleSheet.parseCSS().</warning>
	<warning id="2663" hidden="true" label="kUnsupportedMeth_Object_registerClass">V ActionScriptu 3.0 jsou ve výchozím nastavení registrovány všechny třídy. Používáte-li formát AMF, naleznete další informace u metody flash.utils.registerClassAlias().</warning>
	<warning id="2664" hidden="true" label="kUnsupportedMeth_Object_unwatch">Podobné funkce získáte použitím vlastností mechanismu přístupu (funkce get/set) nebo třídy flash.utils.Proxy.</warning>
	<warning id="2665" hidden="true" label="kUnsupportedMeth_Object_watch">Podobné funkce získáte použitím vlastností mechanismu přístupu (funkce get/set) nebo třídy flash.utils.Proxy.</warning>
	<warning id="2666" hidden="true" label="kUnsupportedMeth_loadMovie">Další informace viz metoda MovieClip.loadMovie().</warning>
	<warning id="2667" hidden="true" label="kUnsupportedMeth_loadMovieNum">Další informace viz metoda MovieClip.loadMovieNum().</warning>
	<warning id="2668" hidden="true" label="kUnsupportedMeth_loadVariables">Další informace viz metoda Loader.load().</warning>
	<warning id="2669" hidden="true" label="kUnsupportedMeth_loadVariablesNum">Další informace viz metoda Loader.load().</warning>
	<warning id="2678" hidden="true" label="kUnsupportedMeth_Stage_addListener">Další informace viz funkce addEventListener (eventName, listener, useCapture, priority).</warning>
	<warning id="2679" hidden="true" label="kUnsupportedMeth_Stage_removeListener">Další informace viz funkce removeEventListener (eventName, listener, useCapture).</warning>
	<warning id="2680" hidden="true" label="kUnsupportedMeth_TextField_addListener">Další informace viz funkce addEventListener (eventName, listener, useCapture, priority).</warning>
	<warning id="2681" hidden="true" label="kUnsupportedMeth_TextField_removeListener">Další informace viz funkce removeEventListener (eventName, listener, useCapture).</warning>
	<warning id="2682" hidden="true" label="kUnsupportedMeth_Mouse_addListener">Další informace viz funkce addEventListener (eventName, listener, useCapture, priority).</warning>
	<warning id="2683" hidden="true" label="kUnsupportedMeth_Mouse_removeListener">Další informace viz funkce removeEventListener (eventName, listener, useCapture).</warning>
	<warning id="2684" hidden="true" label="kUnsupportedMeth_Keyboard_addListener">Další informace viz funkce addEventListener (eventName, listener, useCapture, priority).</warning>
	<warning id="2685" hidden="true" label="kUnsupportedMeth_Keyboard_removeListener">Další informace viz funkce removeEventListener (eventName, listener, useCapture).</warning>
	<warning id="2686" hidden="true" label="kUnsupportedMeth_Sound_attachSound">K vytváření zvuků z knihovny použijte třídu SWF.</warning>
	<warning id="3187" hidden="true" label="kWarning_Event_onStatus">Zpracování události onStatus není přehrávačem Flash za běhu v ActionScriptu 3.0 spouštěno automaticky. Toto zpracování je třeba pro danou událost nejprve zaregistrovat pomocí funkce addEventListener ('status', callback_handler).</warning>
	<warning id="3188" hidden="true" label="kWarning_Event_onID3">Zpracování události onID3 není přehrávačem Flash za běhu v ActionScriptu 3.0 spouštěno automaticky. Toto zpracování je třeba pro danou událost nejprve zaregistrovat pomocí funkce addEventListener ('id3', callback_handler).</warning>
	<warning id="3189" hidden="true" label="kWarning_Event_onLoad">Zpracování události onLoad není přehrávačem Flash za běhu v ActionScriptu 3.0 spouštěno automaticky. Toto zpracování je třeba pro danou událost nejprve zaregistrovat pomocí funkce addEventListener ('load', callback_handler).</warning>
	<warning id="3190" hidden="true" label="kWarning_Event_onSoundComplete">Zpracování události onSoundComplete není přehrávačem Flash za běhu v ActionScriptu 3.0 spouštěno automaticky. Toto zpracování je třeba pro danou událost nejprve zaregistrovat pomocí funkce addEventListener ('soundComplete', callback_handler).</warning>
	<warning id="3191" hidden="true" label="kWarning_Event_onSetFocus">Zpracování události onSetFocus není přehrávačem Flash za běhu v ActionScriptu 3.0 spouštěno automaticky. Toto zpracování je třeba pro danou událost nejprve zaregistrovat pomocí funkce addEventListener ('focusIn', callback_handler).</warning>
	<warning id="3192" hidden="true" label="kWarning_Event_onResize">Zpracování události onResize není přehrávačem Flash za běhu v ActionScriptu 3.0 spouštěno automaticky. Toto zpracování je třeba pro danou událost nejprve zaregistrovat pomocí funkce addEventListener ('resize', callback_handler).</warning>
	<warning id="3193" hidden="true" label="kWarning_Event_onChanged">Ovladač události onChanged není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'change', ovladač_zpětného_volání).</warning>
	<warning id="3194" hidden="true" label="kWarning_Event_onKillFocus">Ovladač události onKillFocus není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'focusOut', ovladač_zpětného_volání).</warning>
	<warning id="3195" hidden="true" label="kWarning_Event_onScroller">Ovladač události onScroller není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'scroll', ovladač_zpětného_volání).</warning>
	<warning id="3198" hidden="true" label="kWarning_Event_onMouseDown">Ovladač události onMouseDown není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'mouseDown', ovladač_zpětného_volání).</warning>
	<warning id="3199" hidden="true" label="kWarning_Event_onMouseUp">Ovladač události onMouseUp není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'mouseUp', ovladač_zpětného_volání).</warning>
	<warning id="3200" hidden="true" label="kWarning_Event_onMouseMove">Ovladač události onMouseMove není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'mouseMove', ovladač_zpětného_volání).</warning>
	<warning id="3201" hidden="true" label="kWarning_Event_onMouseWheel">Ovladač události onMouseWheel není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'mouseWheel', ovladač_zpětného_volání).</warning>
	<warning id="3202" hidden="true" label="kWarning_Event_onKeyDown">Ovladač události onKeyDown není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'keyDown', ovladač_zpětného_volání).</warning>
	<warning id="3203" hidden="true" label="kWarning_Event_onKeyUp">Ovladač události onKeyUp není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'keyUp', ovladač_zpětného_volání).</warning>
	<warning id="3204" hidden="true" label="kWarning_Event_onData">Ovladač události onData není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'data', ovladač_zpětného_volání).</warning>
	<warning id="3205" hidden="true" label="kWarning_Event_onHTTPStatus">Ovladač události onHTTPStatus není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'httpStatus', ovladač_zpětného_volání).</warning>
	<warning id="3206" hidden="true" label="kWarning_Event_onDragOut">Ovladač události onDragOut není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'mouseOut', ovladač_zpětného_volání).</warning>
	<warning id="3207" hidden="true" label="kWarning_Event_onDragOver">Ovladač události onDragOver není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'mouseOver', ovladač_zpětného_volání).</warning>
	<warning id="3211" hidden="true" label="kWarning_Event_onPress">Ovladač události onPress není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'mouseDown', ovladač_zpětného_volání).</warning>
	<warning id="3212" hidden="true" label="kWarning_Event_onRelease">Ovladač události onRelease není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'click', ovladač_zpětného_volání).</warning>
	<warning id="3213" hidden="true" label="kWarning_Event_onReleaseOutside">Ovladač události onReleaseOutside není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'mouseUp', ovladač_zpětného_volání).</warning>
	<warning id="3214" hidden="true" label="kWarning_Event_onRollOut">Ovladač události onRollOut není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'mouseOut', ovladač_zpětného_volání).</warning>
	<warning id="3215" hidden="true" label="kWarning_Event_onRollOver">Ovladač události onRollOver není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'mouseOver', ovladač_zpětného_volání).</warning>
	<warning id="3217" hidden="true" label="kWarning_Event_onActivity">Ovladač události onActivity není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'activity', ovladač_zpětného_volání).</warning>
	<warning id="3219" hidden="true" label="kWarning_Event_onSelect">Ovladač události onSelect není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'menuSelect', ovladač_zpětného_volání).</warning>
	<warning id="3226" hidden="true" label="kWarning_Event_onEnterFrame">Ovladač události onEnterFrame není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'enterFrame', ovladač_zpětného_volání).</warning>
	<warning id="3240" hidden="true" label="kWarning_Event_onUnload">Ovladač události onUnload není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'unload', ovladač_zpětného_volání).</warning>
	<warning id="3241" hidden="true" label="kWarning_Event_onLoadComplete">Ovladač události onLoadComplete není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'load', ovladač_zpětného_volání).</warning>
	<warning id="3242" hidden="true" label="kWarning_Event_onLoadError">Ovladač události onLoadError není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'error', ovladač_zpětného_volání).</warning>
	<warning id="3243" hidden="true" label="kWarning_Event_onLoadInit">Ovladač události onLoadInit není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'init', ovladač_zpětného_volání).</warning>
	<warning id="3244" hidden="true" label="kWarning_Event_onLoadProgress">Ovladač události onLoadProgress není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'progress', ovladač_zpětného_volání).</warning>
	<warning id="3245" hidden="true" label="kWarning_Event_onLoadStart">Ovladač události onLoadStart není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'start', ovladač_zpětného_volání).</warning>
	<warning id="3249" hidden="true" label="kWarning_Event_onClose">Ovladač události onClose není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'close', ovladač_zpětného_volání).</warning>
	<warning id="3250" hidden="true" label="kWarning_Event_onConnect">Ovladač události onConnect není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'connect', ovladač_zpětného_volání).</warning>
	<warning id="3252" hidden="true" label="kWarning_Event_onXML">Ovladač události onXML není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( 'xml', ovladač_zpětného_volání).</warning>
	<warning id="3253" hidden="true" label="kUnsupportedMeth_hasChildNodes">Místo toho použijte metodu hasChildNodes dané vlastnosti.</warning>

  <warning id="3254" hidden="true" label="kUnsupportedMeth_XMLEvent">Třída XMLEvent je zastaralá a událost xml již není odesílána. Při načítání souboru je odesílána pouze událost data.</warning>
  <warning id="3255" hidden="true" label="kUnsupportedMeth_XMLDoc">Třída XMLDoc byla přejmenována na XMLDocument.</warning>
  <warning id="3256" hidden="true" label="kUnsupportedMeth_Accessibility_isActive">Místo toho použijte vlastnost Accessibility.active.</warning>
  <warning id="3257" hidden="true" label="kUnsupportedProp_ActivityEvent_ACTIVITY_TYPE">Místo toho použijte konstantu ActivityEvent.ACTIVITY.</warning>
  <warning id="3258" hidden="true" label="kUnsupportedMeth_SimpleButton_getDepth">Místo toho použijte DisplayObjectContainer.parent.getChildIndex. Viz nápověda pro třídu DisplayObjectContainer, kterou MovieClip rozšiřuje.</warning>
  <warning id="3259" hidden="true" label="kUnsupportedMeth_SimpleButton_swapDepths">Místo toho použijte DisplayObjectContainer.parent.setChildIndex. Viz nápověda pro třídu DisplayObjectContainer, kterou MovieClip rozšiřuje.</warning>
  <warning id="3260" hidden="true" label="kUnsupportedMeth_SimpleButton_getInstanceAtDepth">Místo toho použijte DisplayObjectContainer.getChildAt. Viz nápověda pro třídu DisplayObjectContainer, kterou MovieClip rozšiřuje.</warning>
  <warning id="3261" hidden="true" label="kUnsupportedMeth_SimpleButton_getNextHighestDepth">Místo toho použijte DisplayObjectContainer.numChildren. DisplayObjectContainer.addChild vždy přidá nový podřízený objekt do DisplayObjectContainer.numChildren indexu.</warning>
  <warning id="3262" hidden="true" label="kUnsupportedMeth_ByteArray_available">Místo toho použijte vlastnost ByteArray.bytesAvailable.</warning>
  <warning id="3263" hidden="true" label="kUnsupportedMeth_ByteArray_getFilePointer">Místo toho použijte vlastnost ByteArray.position.</warning>
  <warning id="3264" hidden="true" label="kUnsupportedMeth_ByteArray_seek">Místo toho použijte vlastnost ByteArray.position.</warning>
  <warning id="3265" hidden="true" label="kUnsupportedMeth_Camera_get">Místo toho použijte metodu Camera.getCamera().</warning>
  <warning id="3266" hidden="true" label="kUnsupportedProp_Camera_currentFps">Místo toho použijte vlastnost  Camera.currentFPS.</warning>
  <warning id="3267" hidden="true" label="kUnsupportedMeth_Camera_setKeyFrameInterval">Místo toho použijte vlastnost Camera.keyFrameInterval.</warning>
  <warning id="3268" hidden="true" label="kUnsupportedMeth_Camera_setLoopback">Místo toho použijte vlastnost Camera.loopback.</warning>
  <warning id="3269" hidden="true" label="kUnsupportedMeth_ColorTransform_getRGB">Místo toho použijte vlastnost ColorTransform.color.</warning>
  <warning id="3270" hidden="true" label="kUnsupportedMeth_ColorTransform_setRGB">Místo toho použijte vlastnost ColorTransform.color.</warning>
  <warning id="3271" hidden="true" label="kUnsupportedMeth_DisplayObjectContainer_getTextSnapshot">Místo toho použijte vlastnost Container.textSnapshot.</warning>
  <warning id="3272" hidden="true" label="kUnsupportedMeth_ContextMenu_copy">Místo toho použijte metodu ContextMenu.clone().</warning>
  <warning id="3273" hidden="true" label="kUnsupportedProp_ContextMenu_forward_back">Místo toho použijte vlastnost ContextMenu.forwardAndBack.</warning>
  <warning id="3274" hidden="true" label="kUnsupportedMeth_ContextMenuItem_copy">Místo toho použijte metodu ContextMenuItem.clone().</warning>
  <warning id="3275" hidden="true" label="kUnsupportedMeth_CustomActions_listActions">Místo toho použijte vlastnost CustomActions.actionsList.</warning>
  <warning id="3276" hidden="true" label="kUnsupportedProp_DataEvent_DATA_TYPE">Místo toho použijte konstantu DataEvent.DATA.</warning>
  <warning id="3277" hidden="true" label="kUnsupportedProp_DisplayObject_xscale">Místo toho použijte vlastnost DisplayObject.scaleX.</warning>
  <warning id="3278" hidden="true" label="kUnsupportedProp_DisplayObject__xscale">Místo toho použijte vlastnost DisplayObject.scaleX.</warning>
  <warning id="3279" hidden="true" label="kUnsupportedProp_DisplayObject_yscale">Místo toho použijte vlastnost DisplayObject.scaleY.</warning>
  <warning id="3280" hidden="true" label="kUnsupportedProp_DisplayObject__yscale">Místo toho použijte vlastnost DisplayObject.scaleY.</warning>
  <warning id="3281" hidden="true" label="kUnsupportedProp_DisplayObject_xmouse">Místo toho použijte vlastnost DisplayObject.mouseX.</warning>
  <warning id="3282" hidden="true" label="kUnsupportedProp_DisplayObject__xmouse">Místo toho použijte vlastnost DisplayObject.mouseX.</warning>
  <warning id="3283" hidden="true" label="kUnsupportedProp_DisplayObject_ymouse">Místo toho použijte vlastnost DisplayObject.mouseY.</warning>
  <warning id="3284" hidden="true" label="kUnsupportedProp_DisplayObject__ymouse">Místo toho použijte vlastnost DisplayObject.mouseY.</warning>
  <warning id="3285" hidden="true" label="kUnsupportedProp_DisplayObject_setRootClass">Tato funkce již není podporována.</warning>
  <warning id="3286" hidden="true" label="kUnsupportedProp_DisplayObject_mapSymbolToClass">Tato funkce již není podporována.</warning>
  <warning id="3287" hidden="true" label="kUnsupportedProp_DisplayObject__name">Místo toho použijte vlastnost DisplayObject.name.</warning>
  <warning id="3288" hidden="true" label="kUnsupportedProp_DisplayObject__parent">Místo toho použijte vlastnost DisplayObject.parent.</warning>
  <warning id="3289" hidden="true" label="kUnsupportedProp_DisplayObject__mask">Místo toho použijte vlastnost DisplayObject.mask.</warning>
  <warning id="3290" hidden="true" label="kUnsupportedProp_DisplayObject__visible">Místo toho použijte vlastnost DisplayObject.visible.</warning>
  <warning id="3291" hidden="true" label="kUnsupportedProp_DisplayObject__x">Místo toho použijte vlastnost DisplayObject.x.</warning>
  <warning id="3292" hidden="true" label="kUnsupportedProp_DisplayObject__y">Místo toho použijte vlastnost DisplayObject.y.</warning>
  <warning id="3293" hidden="true" label="kUnsupportedProp_DisplayObject__rotation">Místo toho použijte vlastnost DisplayObject.rotation.</warning>
  <warning id="3294" hidden="true" label="kUnsupportedProp_DisplayObject__alpha">Místo toho použijte vlastnost DisplayObject.alpha.</warning>
  <warning id="3295" hidden="true" label="kUnsupportedProp_DisplayObject__width">Místo toho použijte vlastnost DisplayObject.width.</warning>
  <warning id="3296" hidden="true" label="kUnsupportedProp_DisplayObject__height">Místo toho použijte vlastnost DisplayObject.height.</warning>
  <warning id="3297" hidden="true" label="kUnsupportedMeth_ExternalInterface_available">Místo toho použijte vlastnost ExternalInterface.available.</warning>
  <warning id="3298" hidden="true" label="kUnsupportedProp_ErrorEvent_ERROR_TYPE">Místo toho použijte konstantu ErrorEvent.ERROR.</warning>
  <warning id="3299" hidden="true" label="kUnsupportedMeth_Event_isDefaultPrevented">Místo toho použijte vlastnost Event.isDefaultPrevented.</warning>
  <warning id="3300" hidden="true" label="kUnsupportedProp_Event_ACTIVATE_TYPE">Místo toho použijte konstantu Event.ACTIVATE.</warning>
  <warning id="3301" hidden="true" label="kUnsupportedProp_Event_ADDED_TYPE">Místo toho použijte konstantu Event.ADDED.</warning>
  <warning id="3302" hidden="true" label="kUnsupportedProp_Event_CANCEL_TYPE">Místo toho použijte konstantu Event.CANCEL.</warning>
  <warning id="3303" hidden="true" label="kUnsupportedProp_Event_CHANGE_TYPE">Místo toho použijte konstantu Event.CHANGE.</warning>
  <warning id="3304" hidden="true" label="kUnsupportedProp_Event_CLOSE_TYPE">Místo toho použijte konstantu Event.CLOSE.</warning>
  <warning id="3305" hidden="true" label="kUnsupportedProp_Event_COMPLETE_TYPE">Místo toho použijte konstantu Event.COMPLETE.</warning>
  <warning id="3306" hidden="true" label="kUnsupportedProp_Event_CONNECT_TYPE">Místo toho použijte konstantu Event.CONNECT.</warning>
  <warning id="3307" hidden="true" label="kUnsupportedProp_Event_DEACTIVATE_TYPE">Místo toho použijte konstantu Event.DEACTIVATE.</warning>
  <warning id="3308" hidden="true" label="kUnsupportedProp_Event_ENTER_FRAME_TYPE">Místo toho použijte konstantu Event.ENTER_FRAME.</warning>
  <warning id="3309" hidden="true" label="kUnsupportedProp_Event_ID3_TYPE">Místo toho použijte konstantu Event.ID3.</warning>
  <warning id="3310" hidden="true" label="kUnsupportedProp_Event_INIT_TYPE">Místo toho použijte konstantu Event.INIT.</warning>
  <warning id="3311" hidden="true" label="kUnsupportedProp_Event_MOUSE_LEAVE_TYPE">Místo toho použijte konstantu Event.MOUSE_LEAVE.</warning>
  <warning id="3312" hidden="true" label="kUnsupportedProp_Event_OPEN_TYPE">Místo toho použijte konstantu Event.OPEN.</warning>
  <warning id="3313" hidden="true" label="kUnsupportedProp_Event_REMOVED_TYPE">Místo toho použijte konstantu Event.REMOVED.</warning>
  <warning id="3314" hidden="true" label="kUnsupportedProp_Event_RENDER_TYPE">Místo toho použijte konstantu Event.RENDER.</warning>
  <warning id="3315" hidden="true" label="kUnsupportedProp_Event_RESIZE_TYPE">Místo toho použijte konstantu Event.RESIZE.</warning>
  <warning id="3316" hidden="true" label="kUnsupportedProp_Event_SCROLL_TYPE">Místo toho použijte konstantu Event.SCROLL.</warning>
  <warning id="3317" hidden="true" label="kUnsupportedProp_Event_SELECT_TYPE">Místo toho použijte konstantu Event.SELECT.</warning>
  <warning id="3318" hidden="true" label="kUnsupportedProp_Event_SOUND_COMPLETE_TYPE">Místo toho použijte konstantu Event.SOUND_COMPLETE.</warning>
  <warning id="3319" hidden="true" label="kUnsupportedProp_Event_TAB_CHILDREN_CHANGE_TYPE">Místo toho použijte konstantu Event.TAB_CHILDREN_CHANGE.</warning>
  <warning id="3320" hidden="true" label="kUnsupportedProp_Event_TAB_ENABLED_CHANGE_TYPE">Místo toho použijte konstantu Event.TAB_ENABLED_CHANGE.</warning>
  <warning id="3321" hidden="true" label="kUnsupportedProp_Event_TAB_INDEX_CHANGE_TYPE">Místo toho použijte konstantu Event.TAB_INDEX_CHANGE.</warning>
  <warning id="3322" hidden="true" label="kUnsupportedProp_Event_UNLOAD_TYPE">Místo toho použijte konstantu Event.UNLOAD.</warning>
  <warning id="3323" hidden="true" label="kUnsupportedProp_FocusEvent_FOCUS_IN_TYPE">Místo toho použijte konstantu FocusEvent.FOCUS_IN.</warning>
  <warning id="3324" hidden="true" label="kUnsupportedProp_FocusEvent_FOCUS_OUT_TYPE">Místo toho použijte konstantu FocusEvent.FOCUS_OUT.</warning>
  <warning id="3325" hidden="true" label="kUnsupportedProp_FocusEvent_KEY_FOCUS_CHANGE_TYPE">Místo toho použijte konstantu FocusEvent.KEY_FOCUS_CHANGE.</warning>
  <warning id="3326" hidden="true" label="kUnsupportedProp_FocusEvent_MOUSE_FOCUS_CHANGE_TYPE">Místo toho použijte konstantu FocusEvent.MOUSE_FOCUS_CHANGE.</warning>
  <warning id="3327" hidden="true" label="kUnsupportedMeth_Graphics_beginImageFill">Místo toho použijte metodu Graphics.beginBitmapFill().</warning>
  <warning id="3328" hidden="true" label="kUnsupportedProp_BitmapFilter_XYZ_QUALITY">Místo toho použijte vlastnost BitmapFilter.quality.</warning>
  <warning id="3329" hidden="true" label="kUnsupportedMeth_Keyboard_getAscii">Místo toho použijte KeyboardEvent.charCode.</warning>
  <warning id="3330" hidden="true" label="kUnsupportedMeth_Keyboard_getCode">Místo toho použijte KeyboardEvent.keyCode.</warning>
  <warning id="3331" hidden="true" label="kUnsupportedMeth_Keyboard_isDown">Více informací viz třída KeyboardEvent.</warning>
  <warning id="3332" hidden="true" label="kUnsupportedMeth_Keyboard_isToggled">Více informací viz KeyboardEvent.ctrlKey, KeyboardEvent.altKey a KeyboardEvent.shiftKey.</warning>
  <warning id="3333" hidden="true" label="kUnsupportedProp_Keyboard_PGDN">Místo toho použijte konstantu PAGE_DOWN.</warning>
  <warning id="3334" hidden="true" label="kUnsupportedProp_Keyboard_PGUP">Místo toho použijte konstantu PAGE_UP.</warning>
  <warning id="3335" hidden="true" label="kUnsupportedProp_Keyboard_DELETEKEY">Místo toho použijte konstantu DELETE.</warning>
  <warning id="3336" hidden="true" label="kUnsupportedProp_Keyboard_CAPSLOCK">Místo toho použijte konstantu CAPS_LOCK.</warning>
  <warning id="3337" hidden="true" label="kUnsupportedProp_Keyboard_NUMPAD">Místo toho použijte jednu z konstant NUMPAD_0 -> NUMPAD_9.</warning>
 
  <warning id="3338" hidden="true" label="kUnsupportedProp_InteractiveObject__focusrect">Místo toho použijte vlastnost InteractiveObject.focusRect.</warning>
  <warning id="3339" hidden="true" label="kUnsupportedProp_InteractiveObject_menu">Místo toho použijte vlastnost InteractiveObject.contextMenu.</warning>
  <warning id="3340" hidden="true" label="kUnsupportedProp_KeyboardEvent_ascii">Místo toho použijte vlastnost KeyboardEvent.charCode.</warning>
  <warning id="3341" hidden="true" label="kUnsupportedProp_KeyboardEvent_code">Místo toho použijte vlastnost KeyboardEvent.keyCode.</warning>
  <warning id="3342" hidden="true" label="kUnsupportedProp_Loader_loaderInfo">Místo toho použijte vlastnost Loader.contentLoaderInfo.</warning>
  <warning id="3343" hidden="true" label="kUnsupportedProp_Loader_preload">Tato funkce již není podporována.</warning>
  <warning id="3344" hidden="true" label="kUnsupportedProp_Loader_loadCached">Tato funkce již není podporována.</warning>
  <warning id="3345" hidden="true" label="kUnsupportedProp_LoaderInfo_loaderUrl">Místo toho použijte vlastnost LoaderInfo.loaderURL.</warning>
  <warning id="3346" hidden="true" label="kUnsupportedMeth_LocalConnection_domain">Místo toho použijte vlastnost LocalConnection.domain.</warning>
  <warning id="3347" hidden="true" label="kUnsupportedProp_ContextMenuEvent_menuOwner">Místo toho použijte vlastnost MenuEvent.contextMenuOwner.</warning>
  <warning id="3348" hidden="true" label="kUnsupportedMeth_Microphone_get">Místo toho použijte metodu Microphone.getMicrophone().</warning>
  <warning id="3349" hidden="true" label="kUnsupportedMeth_MovieClip_attachMovie">Pokud název podtřídy MovieClip je A, použijte var mc= new A(); addChild(mc). Více informací viz třída DisplayObjectContainer.</warning>
  <warning id="3350" hidden="true" label="kUnsupportedMeth_MovieClip_createEmptyMovieClip">Použijte var mc= new MovieClip(); addChild(mc). Více informací viz třída DisplayObjectContainer.</warning>
  <warning id="3351" hidden="true" label="kUnsupportedMeth_MovieClip_createTextField">Použijte var tf= new TextField(); addChild(mc). Více informací viz třída DisplayObjectContainer.</warning>
  <warning id="3352" hidden="true" label="kUnsupportedMeth_MovieClip_removeMovieClip">Použijte Container.removeChild(childName). Více informací viz třída DisplayObjectContainer.</warning>
  <warning id="3353" hidden="true" label="kUnsupportedMeth_MovieClip_loadMovie">Použijte var l = new Loader(); addChild(l); l.load(new URLRequest("vaše url"));. Více informací viz třídy Loader a DisplayObjectContainer.</warning>
  <warning id="3354" hidden="true" label="kUnsupportedMeth_MovieClip_unloadMovie">Místo toho použijte DisplayObjectContainer.removeChild(childName). Více informací viz třída DisplayObjectContainer.</warning>
  <warning id="3355" hidden="true" label="kUnsupportedMeth_MovieClip_unloadMovieNum">Místo toho použijte DisplayObjectContainer.removeChild(childName). Více informací viz třída DisplayObjectContainer.</warning>
  <warning id="3356" hidden="true" label="kUnsupportedMeth_MovieClip_getDepth">Místo toho použijte DisplayObjectContainer.parent.getChildIndex. Více informací viz třída DisplayObjectContainer, kterou MovieClip rozšiřuje.</warning>
  <warning id="3357" hidden="true" label="kUnsupportedMeth_MovieClip_swapDepths">Místo toho použijte DisplayObjectContainer.parent.setChildIndex. Více informací viz třída DisplayObjectContainer, kterou MovieClip rozšiřuje.</warning>
  <warning id="3358" hidden="true" label="kUnsupportedMeth_MovieClip_getInstanceAtDepth">Místo toho použijte DisplayObjectContainer.getChildAt. Více informací viz třída DisplayObjectContainer, kterou MovieClip rozšiřuje.</warning>
  <warning id="3359" hidden="true" label="kUnsupportedMeth_MovieClip_getNextHighestDepth">Místo toho použijte DisplayObjectContainer.numChildren. DisplayObjectContainer.addChild vždy přidá nový podřízený objekt do DisplayObjectContainer.numChildren indexu.</warning>
  <warning id="3360" hidden="true" label="kUnsupportedMeth_MovieClip_attachAudio">Více informací viz DisplayObject.addChild.</warning>
  <warning id="3361" hidden="true" label="kUnsupportedMeth_MovieClip_getBytesLoaded">Více informací viz LoaderInfo.bytesLoaded a třída Loader.</warning>
  <warning id="3362" hidden="true" label="kUnsupportedMeth_MovieClip_getBytesTotal">Více informací viz LoaderInfo.bytesTotal a třída Loader.</warning>
  <warning id="3363" hidden="true" label="kUnsupportedMeth_MovieClip_getURL">Ekvivalentní funkčnost viz flash.net.URLLoader. Balíček flash.net obsahuje rovněž funkce úrovně balíčku navigateToURL() a sendToURL().</warning>
  <warning id="3364" hidden="true" label="kUnsupportedProp_MovieClip_url">Více informací viz LoaderInfo.url a třída Loader.</warning>
  <warning id="3365" hidden="true" label="kUnsupportedProp_MovieClip__url">Více informací viz LoaderInfo.url a třída Loader.</warning>
  <warning id="3366" hidden="true" label="kUnsupportedMeth_MovieClip_setMask">Místo toho použijte vlastnost MovieClip.mask.</warning>
  <warning id="3367" hidden="true" label="kUnsupportedMeth_MovieClip_getSWFVersion">Více informací viz LoaderInfo.swfVersion a třída Loader.</warning>
  <warning id="3368" hidden="true" label="kUnsupportedProp_MovieClip__currentframe">Místo toho použijte vlastnost MovieClip.currentFrame.</warning>
  <warning id="3369" hidden="true" label="kUnsupportedProp_MovieClip__framesloaded">Místo toho použijte vlastnost MovieClip.framesLoaded.</warning>
  <warning id="3370" hidden="true" label="kUnsupportedProp_MovieClip__totalframes">Místo toho použijte vlastnost MovieClip.totalFrames.</warning>
  <warning id="3371" hidden="true" label="kUnsupportedProp_MovieClip_lockroot">Více informací viz displayObjectInstance.root.</warning>
  <warning id="3372" hidden="true" label="kUnsupportedProp_MovieClip__lockroot">Více informací viz displayObjectInstance.root.</warning>
  <warning id="3373" hidden="true" label="kUnsupportedProp_MovieClip__soundbuftime">Místo toho použijte statickou vlastnost flash.media.SoundMixer.bufferTime.</warning>
  <warning id="3374" hidden="true" label="kUnsupportedMeth_MovieClip_clear">Více informací viz třída Graphics.</warning>
  <warning id="3375" hidden="true" label="kUnsupportedMeth_MovieClip_beginFill">Více informací viz třída Graphics.</warning>
  <warning id="3376" hidden="true" label="kUnsupportedMeth_MovieClip_beginGradientFill">Více informací viz třída Graphics.</warning>
  <warning id="3377" hidden="true" label="kUnsupportedMeth_MovieClip_lineGradientStyle">Více informací viz třída Graphics.</warning>
  <warning id="3378" hidden="true" label="kUnsupportedMeth_MovieClip_beginImageFill">Více informací viz třída Graphics.</warning>
  <warning id="3379" hidden="true" label="kUnsupportedMeth_MovieClip_lineStyle">Více informací viz třída Graphics.</warning>
  <warning id="3380" hidden="true" label="kUnsupportedMeth_MovieClip_drawRect">Více informací viz třída Graphics.</warning>
  <warning id="3381" hidden="true" label="kUnsupportedMeth_MovieClip_drawRoundRect">Více informací viz třída Graphics.</warning>
  <warning id="3382" hidden="true" label="kUnsupportedMeth_MovieClip_drawRoundRectComplex">Více informací viz třída Graphics.</warning>
  <warning id="3383" hidden="true" label="kUnsupportedMeth_MovieClip_drawCircle">Více informací viz třída Graphics.</warning>
  <warning id="3384" hidden="true" label="kUnsupportedMeth_MovieClip_moveTo">Více informací viz třída Graphics.</warning>
  <warning id="3385" hidden="true" label="kUnsupportedMeth_MovieClip_lineTo">Více informací viz třída Graphics.</warning>
  <warning id="3386" hidden="true" label="kUnsupportedMeth_MovieClip_curveTo">Více informací viz třída Graphics.</warning>
  <warning id="3387" hidden="true" label="kUnsupportedMeth_MovieClip_endFill">Více informací viz třída Graphics.</warning>
  <warning id="3388" hidden="true" label="kUnsupportedMeth_NetStream_setBufferTime">Místo toho použijte vlastnost NetStream.bufferTime.</warning>
  <warning id="3389" hidden="true" label="kUnsupportedProp_NetStream_currentFps">Místo toho použijte vlastnost NetStream.currentFPS.</warning>
  <warning id="3390" hidden="true" label="kUnsupportedProp_NetStream_videocodec">Místo toho použijte vlastnost NetStream.videoCodec.</warning>
  <warning id="3391" hidden="true" label="kUnsupportedProp_NetStream_audiocodec">Místo toho použijte vlastnost NetStream.audioCodec.</warning>
  <warning id="3392" hidden="true" label="kUnsupportedMeth_ProductManager_isIntalled">Místo toho použijte vlastnost ProductManager.isInstalled.</warning>
  <warning id="3393" hidden="true" label="kUnsupportedMeth_ProductManager_installedVersion">Místo toho použijte vlastnost ProductManager.installedVersion.</warning>
  <warning id="3394" hidden="true" label="kUnsupportedMeth_ProductManager_isRunning">Místo toho použijte vlastnost ProductManager.isRunning.</warning>
  <warning id="3395" hidden="true" label="kUnsupportedMeth_Point_addTo">Místo toho použijte metodu Point.add().</warning>
  <warning id="3396" hidden="true" label="kUnsupportedProp_Proxy_delDescendants">Místo toho použijte vlastnost Proxy.deleteDescendants.</warning>
  <warning id="3397" hidden="true" label="kUnsupportedMeth_Profiler_heapdump">Místo toho použijte metodu heapDump().</warning>
  <warning id="3398" hidden="true" label="kUnsupportedProp_ProgressEvent_current">Místo toho použijte vlastnost ProgressEvent.bytesLoaded.</warning>
  <warning id="3399" hidden="true" label="kUnsupportedProp_ProgressEvent_total">Místo toho použijte vlastnost ProgressEvent.bytesTotal.</warning>
  <warning id="3400" hidden="true" label="kUnsupportedMeth_Rectangle_isEmpty">Místo toho použijte vlastnost Rectangle.isEmpty.</warning>  
  <warning id="3401" hidden="true" label="kUnsupportedMeth_SoundTransform_setPan">Místo toho použijte vlastnost SoundTransform.pan.</warning>
  <warning id="3402" hidden="true" label="kUnsupportedMeth_Socket_available">Místo toho použijte vlastnost Sockect.bytesAvailable.</warning>
  <warning id="3403" hidden="true" label="kUnsupportedMeth_SharedObject_getSize">Místo toho použijte vlastnost SharedObject.size.</warning>
  <warning id="3404" hidden="true" label="kUnsupportedMeth_SharedObject_setFps">Místo toho použijte vlastnost SharedObject.fps.</warning>
  <warning id="3405" hidden="true" label="kUnsupportedMeth_Sprite_getSWF">Tato funkce již není podporována.</warning>
  <warning id="3406" hidden="true" label="kUnsupportedMeth_Sprite_constructChild">Místo toho použijte metodu Sprite.constructChildren().</warning>
  <warning id="3407" hidden="true" label="kUnsupportedProp_Sprite__droptarget">Místo toho použijte vlastnost Sprite.dropTarget.</warning>
  <warning id="3408" hidden="true" label="kUnsupportedMeth_Stage_getFocus">Místo toho použijte vlastnost Stage.focus.</warning>
  <warning id="3409" hidden="true" label="kUnsupportedMeth_Stage_setFocus">Místo toho použijte vlastnost Stage.focus.</warning>
  <warning id="3411" hidden="true" label="kUnsupportedProp_Stage_showMenu">Místo toho použijte vlastnost Stage.showDefaultContextMenu.</warning>
  <warning id="3412" hidden="true" label="kUnsupportedMeth_StyleSheet_getStyleNames">Místo toho použijte vlastnost StyleSheet.styleNames.</warning>
  <warning id="3413" hidden="true" label="kUnsupportedMeth_StyleSheet_onData">Použijte instanci URLLoader k načtení dat StyleSheet a potom pošlete data zaváděčů metodě StyleSheet.parseCSS. Více informací viz třídy URLLoader a EventDispatcher.</warning>
  <warning id="3414" hidden="true" label="kUnsupportedMeth_StyleSheet_load">Použijte instanci URLLoader k načtení dat StyleSheet a potom pošlete data zaváděčů metodě StyleSheet.parseCSS. Více informací viz třídy URLLoader a EventDispatcher.</warning>
  <warning id="3415" hidden="true" label="kUnsupportedProp_StyleSheet_loaded">Použijte instanci URLLoader k načtení dat StyleSheet a potom pošlete data zaváděčů metodě StyleSheet.parseCSS. Více informací viz třídy URLLoader a EventDispatcher.</warning>
  <warning id="3416" hidden="true" label="kUnsupportedMeth_StyleSheet_getBytesLoaded">Použijte instanci URLLoader k načtení dat StyleSheet a potom pošlete data zaváděčů metodě StyleSheet.parseCSS. Více informací viz třídy URLLoader a EventDispatcher.</warning>
  <warning id="3417" hidden="true" label="kUnsupportedMeth_StyleSheet_getBytesTotal">Použijte instanci URLLoader k načtení dat StyleSheet a potom pošlete data zaváděčů metodě StyleSheet.parseCSS. Více informací viz třídy URLLoader a EventDispatcher.</warning>
  <warning id="3418" hidden="true" label="kUnsupportedMeth_IME_getEnabled">Místo toho použijte vlastnost IME.enabled.</warning>
  <warning id="3419" hidden="true" label="kUnsupportedMeth_IME_setEnabled">Místo toho použijte vlastnost IME.enabled.</warning>
  <warning id="3420" hidden="true" label="kUnsupportedMeth_IME_getInstance">Místo toho použijte vlastnost IME.instance.</warning>
  <warning id="3421" hidden="true" label="kUnsupportedMeth_IME_getConversionMode">Místo toho použijte vlastnost IME.conversionMode.</warning>
  <warning id="3422" hidden="true" label="kUnsupportedMeth_IME_setConversionMode">Místo toho použijte vlastnost IME.conversionMode.</warning>
  <warning id="3423" hidden="true" label="kUnsupportedProp_System_getAvmplusVersion">Místo toho použijte vlastnost System.vmVersion.</warning>
  <warning id="3424" hidden="true" label="kUnsupportedProp_SWFLoaderInfo_SWFVersion">Místo toho použijte vlastnost SWFLoaderInfo.swfVersion.</warning>
  <warning id="3425" hidden="true" label="kUnsupportedProp_SWFLoaderInfo_ASVersion">Místo toho použijte vlastnost SWFLoaderInfo.actionScriptVersion.</warning>
  <warning id="3426" hidden="true" label="kUnsupportedMeth_TextField_getNewTextFormat">Místo toho použijte vlastnost TextField.defaultTextFormat.</warning>
  <warning id="3427" hidden="true" label="kUnsupportedMeth_TextField_setNewTextFormat">Místo toho použijte vlastnost TextField.defaultTextFormat.</warning>
  <warning id="3428" hidden="true" label="kUnsupportedMeth_TextField_getDepth">Místo toho použijte DisplayObjectContainer.parent.getChildIndex. Více informací viz třída DisplayObjectContainer, kterou MovieClip rozšiřuje.</warning>
  <warning id="3429" hidden="true" label="kUnsupportedMeth_TextField_swapDepths">Místo toho použijte DisplayObjectContainer.parent.setChildIndex. Více informací viz třída DisplayObjectContainer, kterou MovieClip rozšiřuje.</warning>
  <warning id="3430" hidden="true" label="kUnsupportedMeth_TextField_getInstanceAtDepth">Místo toho použijte DisplayObjectContainer.getChildAt. Více informací viz třída DisplayObjectContainer, kterou MovieClip rozšiřuje.</warning>
  <warning id="3431" hidden="true" label="kUnsupportedMeth_TextField_getNextHighestDepth">Místo toho použijte DisplayObjectContainer.numChildren.  DisplayObjectContainer.addChild vždy přidá nový podřízený objekt do DisplayObjectContainer.numChildren indexu.</warning>
  <warning id="3432" hidden="true" label="kUnsupportedMeth_TextField_replaceSel">Místo toho použijte metodu TextField.replaceSelectedText().</warning>
  <warning id="3433" hidden="true" label="kUnsupportedMeth_TextField_getLineIndexOfCharacter">Místo toho použijte metodu TextField.getLineIndexOfChar().</warning>
  <warning id="3434" hidden="true" label="kUnsupportedMeth_TextField_getSelectionBeginIndex">Místo toho použijte vlastnost TextField.selectionBeginIndex.</warning>
  <warning id="3435" hidden="true" label="kUnsupportedMeth_TextField_getSelectionEndIndex">Místo toho použijte vlastnost TextField.selectionEndIndex.</warning>
  <warning id="3436" hidden="true" label="kUnsupportedMeth_TextField_getCaretIndex">Místo toho použijte vlastnost TextField.caretIndex.</warning>
  <warning id="3437" hidden="true" label="kUnsupportedMeth_TextField_getFontList">Místo toho použijte metodu Font.enumerateFonts().</warning>
  <warning id="3438" hidden="true" label="kUnsupportedProp_TextField_maxscroll">Místo toho použijte vlastnost TextField.maxScrollV.</warning>
  <warning id="3439" hidden="true" label="kUnsupportedProp_TextField_hscroll">Místo toho použijte vlastnost TextField.scrollH.</warning>
  <warning id="3440" hidden="true" label="kUnsupportedProp_TextField_maxhscroll">Místo toho použijte vlastnost TextField.maxScrollH.</warning>
  <warning id="3441" hidden="true" label="kUnsupportedProp_TextField_newTextFormat">Místo toho použijte vlastnost TextField.defaultTextFormat.</warning>
  <warning id="3442" hidden="true" label="kUnsupportedMeth_TextFormat_getTextExtent">Vytvořte dočasný objekt TextField a místo toho použijte TextField.getLineMetrics.</warning>
  <warning id="3443" hidden="true" label="kUnsupportedMeth_TextSnapshot_getCount">Místo toho použijte vlastnost TextSnapshot.charCount.</warning>
  <warning id="3444" hidden="true" label="kUnsupportedProp_URLLoader_navigate">Místo toho použijte metodu navigateToURL() v balíčku flash.net.</warning>
  <warning id="3445" hidden="true" label="kUnsupportedMeth_URLLoader_send">Místo toho použijte metodu sendToURL() v balíčku flash.net.</warning>
  <warning id="3446" hidden="true" label="kUnsupportedProp_URLLoader_binary">Místo toho použijte vlastnost URLLoader.dataFormat.</warning>
  <warning id="3447" hidden="true" label="kUnsupportedMeth_URLStream_available">Místo toho použijte vlastnost URLStream.bytesAvailable.</warning>
  <warning id="3448" hidden="true" label="kUnsupportedProp_URLRequest_digest">Tato vlastnost již není podporována.</warning>
  <warning id="3449" hidden="true" label="kUnsupportedProp_URLRequest_importToSandbox">Místo toho použijte vlastnost URLRequest.applicationDomain.</warning>
  <warning id="3450" hidden="true" label="kUnsupportedMeth_URLRequest_addRequestHeader">Chcete-li přidat záhlaví požadavků, nastavte vlastnost URLRequest.requestHeaders do pole objektů URLRequestHeader.</warning>
  <warning id="3451" hidden="true" label="kUnsupportedMeth_XMLDocument_load">Použijte instanci URLLoader k načtení souboru XML, potom pošlete data URLLoaders konstruktoru XMLDocuments. Více informací viz třídy URLLoader a EventDispatcher.</warning>
  <warning id="3452" hidden="true" label="kUnsupportedMeth_XMLDocument_send">Místo toho použijte metodu sendToURL() v balíčku flash.net.</warning>
  <warning id="3453" hidden="true" label="kUnsupportedMeth_XMLDocument_sendAndLoad">Nastavte vlastnost postData objektu URLRequest a použijte jej s objektem URLLoader k načtení souboru XML. Pošlete data URLLoaders konstruktoru XMLDocuments. Více informací viz třídy URLLoader, URLRequest a EventDispatcher.</warning>
  <warning id="3454" hidden="true" label="kUnsupportedMeth_XMLDocument_onData">Použijte instanci URLLoader k načtení souboru XML, potom pošlete data URLLoaders konstruktoru XMLDocuments. Více informací viz třídy URLLoader a EventDispatcher.</warning>
  <warning id="3455" hidden="true" label="kUnsupportedMeth_XMLDocument_addRequestHeader">Chcete-li přidat záhlaví požadavků, nastavte vlastnost URLRequest.requestHeaders do pole objektů URLRequestHeader.</warning>
  <warning id="3456" hidden="true" label="kUnsupportedMeth_XMLDocument_getBytesLoaded">Více informací viz URLLoader.bytesLoaded a třída URLLoader.</warning>
  <warning id="3457" hidden="true" label="kUnsupportedMeth_XMLDocument_getBytesTotal">Více informací viz URLLoader.bytesTotal a třída URLLoader.</warning>
  <warning id="3458" hidden="true" label="kUnsupportedProp_XMLDocument_loaded">Použijte instanci URLLoader k načtení souboru XML, potom pošlete data zaváděčů metodě StyleSheet.parseCSS. Více informací viz třídy URLLoader a EventDispatcher.</warning>
  <warning id="3459" hidden="true" label="kUnsupportedProp_XMLDocument_contentType">Místo toho použijte vlastnost URLRequest.contentType.</warning>
  <warning id="3460" hidden="true" label="kUnsupportedProp_XMLDocument_status">Místo toho zkontrolujte možné výjimky vyvolané konstruktorem XMLDocument nebo metodou XMLDocument.parseXML. Více informací viz XMLDocument.</warning>

  <!-- renamed types could be detected with a prop access ala "Keyboard.DELETE" or as a function ala "a = Image(b)".  The following kUnsupportedProp_ strings are duplicated below for catching the kUnsupportedMeth_ cases -->
  <warning id="3461" hidden="true" label="kUnsupportedProp_Button">Třída Button byla přejmenována na SimpleButton.</warning>
  <warning id="3462" hidden="true" label="kUnsupportedProp_Container">Třída Container byla přejmenována na DisplayObjectContainer.</warning>
  <warning id="3463" hidden="true" label="kUnsupportedProp_Image">Třída Image byla přejmenována na BitmapData.</warning>
  <warning id="3464" hidden="true" label="kUnsupportedProp_ImageFilter">Třída ImageFilter byla přejmenována na BitmapFilter.</warning>
  <warning id="3465" hidden="true" label="kUnsupportedProp_ImageSprite">Třída ImageSprite byla přejmenována na Bitmap.</warning>
  <warning id="3466" hidden="true" label="kUnsupportedProp_ImageLoaderInfo">Třída ImageLoaderInfo byla přejmenována na BitmapLoaderInfo.</warning>
  <warning id="3467" hidden="true" label="kUnsupportedProp_ImeEvent">Třída ImeEvent byla přejmenována na IMEEvent.</warning>
  <warning id="3468" hidden="true" label="kUnsupportedProp_Key">Třída Key byla přejmenována na Keyboard.</warning>
  <warning id="3469" hidden="true" label="kUnsupportedProp_LineMetrics">Třída LineMetrics byla přejmenována na TextLineMetrics.</warning>
  <warning id="3470" hidden="true" label="kUnsupportedProp_LoadVars">Více informací viz třída URLVariables, vlastnosti URLRequest.urlVariables a URLRequest.postData a vlastnost URLLoader.dataFormat.</warning>
  <warning id="3471" hidden="true" label="kUnsupportedProp_MenuEvent">Třída MenuEvent byla přejmenována na ContextMenuEvent.</warning>
  <warning id="3472" hidden="true" label="kUnsupportedProp_SystemCapabilities">Třída SystemCapabilities byla přejmenována na Capabilities.</warning>
  <warning id="3473" hidden="true" label="kUnsupportedProp_TextExtents">Místo toho použijte vlastnost TextField.getLineMetrics.</warning>

  <warning id="3475" hidden="true" label="kUnsupportedMeth_Button">Třída Button byla přejmenována na SimpleButton.</warning>
  <warning id="3476" hidden="true" label="kUnsupportedMeth_Container">Třída Container byla přejmenována na DisplayObjectContainer.</warning>
  <warning id="3477" hidden="true" label="kUnsupportedMeth_Image">Třída Image byla přejmenována na BitmapData.</warning>
  <warning id="3478" hidden="true" label="kUnsupportedMeth_ImageFilter">Třída ImageFilter byla přejmenována na BitmapFilter.</warning>
  <warning id="3479" hidden="true" label="kUnsupportedMeth_ImageSprite">Třída ImageSprite byla přejmenována na Bitmap.</warning>
  <warning id="3480" hidden="true" label="kUnsupportedMeth_ImageLoaderInfo">Třída ImageLoaderInfo byla přejmenována na BitmapLoaderInfo.</warning>
  <warning id="3481" hidden="true" label="kUnsupportedMeth_ImeEvent">Třída ImeEvent byla přejmenována na IMEEvent.</warning>
  <warning id="3482" hidden="true" label="kUnsupportedMeth_Key">Třída Key byla přejmenována na Keyboard.</warning>
  <warning id="3483" hidden="true" label="kUnsupportedMeth_LineMetrics">Třída LineMetrics byla přejmenována na TextLineMetrics.</warning>
  <warning id="3484" hidden="true" label="kUnsupportedMeth_LoadVars">Více informací viz třída URLVariables, vlastnosti URLRequest.urlVariables a URLRequest.postData a vlastnost URLLoader.dataFormat.</warning>
  <warning id="3485" hidden="true" label="kUnsupportedMeth_MenuEvent">Třída MenuEvent byla přejmenována na ContextMenuEvent.</warning>
  <warning id="3486" hidden="true" label="kUnsupportedMeth_SystemCapabilities">Třída SystemCapabilities byla přejmenována na Capabilities.</warning>
  <warning id="3487" hidden="true" label="kUnsupportedMeth_TextExtents">Místo toho použijte vlastnost TextField.getLineMetrics.</warning>
  <warning id="3488" hidden="true" label="kUnsupportedProp_Object___resolve ">Více informací viz nápověda pro třídu Proxy, jež nabízí podobnou funkčnost.</warning>
  <warning id="3489" hidden="true" label="kUnsupportedMeth_XMLUI_get">Místo toho použijte metodu XMLUI.getProperty.</warning>
  <warning id="3490" hidden="true" label="kUnsupportedMeth_XMLUI_set">Místo toho použijte metodu XMLUI.setProperty.</warning>
  <warning id="3491" hidden="true" label="kUnsupportedProp_DisplayObject_accProps">Místo toho použijte vlastnost DisplayObject.accessibilityProperties.</warning>
  <warning id="3492" hidden="true" label="kUnsupportedMeth_DisplayObject_setScalingGrid">Místo toho použijte vlastnost DisplayObject.scale9Grid.</warning>
  <warning id="3493" hidden="true" label="kUnsupportedMeth_Graphics_drawCircle">Místo toho použijte metodu Graphics.drawOval.</warning>
  <warning id="3494" hidden="true" label="kUnsupportedProp_NetConnection_isConnected">Místo toho použijte vlastnost NetConnection.connected.</warning>
  <warning id="3495" hidden="true" label="kUnsupportedProp_Socket_isConnected">Místo toho použijte vlastnost Socket.connected.</warning>
  <warning id="3496" hidden="true" label="kUnsupportedProp_URLStream_isConnected">Místo toho použijte vlastnost URLStream.connected.</warning>
  <warning id="3497" hidden="true" label="kUnsupportedProp_SyncEvent_list">Místo toho použijte vlastnost SyncEvent.changeList.</warning>
  <warning id="3498" hidden="true" label="kUnsupportedProp_TextField_scroll">Místo toho použijte vlastnost TextField.scrollV.</warning>
  <warning id="3499" hidden="true" label="kUnsupportedProp_TextField_bottomScroll">Místo toho použijte vlastnost TextField.bottomScrollV.</warning>
  <warning id="3500" hidden="true" label="kUnsupportedProp_BitmapData_RED_CHANNEL">Místo toho použijte konstantu BitmapDataChannel.RED.</warning>
  <warning id="3501" hidden="true" label="kUnsupportedProp_BitmapData_GREEN_CHANNEL">Místo toho použijte konstantu BitmapDataChannel.GREEN.</warning>
  <warning id="3502" hidden="true" label="kUnsupportedProp_BitmapData_BLUE_CHANNEL">Místo toho použijte konstantu BitmapDataChannel.BLUE.</warning>
  <warning id="3503" hidden="true" label="kUnsupportedProp_BitmapData_ALPHA_CHANNEL">Místo toho použijte konstantu BitmapDataChannel.ALPHA.</warning>
  <warning id="3504" hidden="true" label="kUnsupportedMeth_instanceof">Místo toho použijte operátor is.</warning>

  <warning id="3505" hidden="true" label="kUnsupportedMeth_System_showSettings">Místo toho použijte metodu flash.system.Security.showSettings.</warning>
  <warning id="3506" hidden="true" label="kUnsupportedProp_System_useCodepage">Místo toho použijte vlastnost System.useCodePage.</warning>
  <warning id="3507" hidden="true" label="kUnsupportedProp_AsBroadcaster">Místo toho použijte třídu flash.events.EventDispatcher.</warning>
  <warning id="3508" hidden="true" label="kUnsupportedProp_SimpleButton_Soundbuftime">Místo toho použijte statickou vlastnost flash.media.SoundMixer.bufferTime.</warning>
  <warning id="3509" hidden="true" label="kUnsupportedMeth_BitmapData_loadBitmap">Místo toho vytvořte novou instanci třídy bitmapových symbolů knihovny, tzn. novou myBitmapName().</warning>
  <warning id="3510" hidden="true" label="kUnsupportedMeth_MovieClip_loadVariables">Více informací viz Loader.load().</warning>
  <warning id="3511" hidden="true" label="kUnsupportedProp_MovieClipLoader">Třída MovieClipLoader byla nahrazena třídou flash.display.Loader.</warning>
  <warning id="3512" hidden="true" label="kUnsupportedMeth_MovieClipLoader">Třída MovieClipLoader byla nahrazena třídou flash.display.Loader.</warning>

  <warning id="3513" hidden="true" label="kUnsupportedMeth_IME_addListener">Více informací viz addEventListener(eventName, listener, useCapture, priority ).</warning>
  <warning id="3514" hidden="true" label="kUnsupportedMeth_IME_removeListener">Více informací viz removeEventListener(eventName, listener, useCapture).</warning>
  <warning id="3515" hidden="true" label="kUnsupportedProp_IME_ALPHANUMERIC_FULL">Místo toho použijte konstantu flash.system.IMEConversionMode.ALPHANUMERIC_FULL.</warning>
  <warning id="3516" hidden="true" label="kUnsupportedProp_IME_ALPHANUMERIC_HALF">Místo toho použijte konstantu flash.system.IMEConversionMode.ALPHANUMERIC_HALF.</warning>
  <warning id="3517" hidden="true" label="kUnsupportedProp_IME_CHINESE">Místo toho použijte konstantu flash.system.IMEConversionMode.CHINESE.</warning>
  <warning id="3518" hidden="true" label="kUnsupportedProp_IME_JAPANESE_HIRAGANA">Místo toho použijte konstantu flash.system.IMEConversionMode.JAPANESE_HIRAGANA.</warning>
  <warning id="3519" hidden="true" label="kUnsupportedProp_IME_JAPANESE_KATAKANA_FULL">Místo toho použijte konstantu flash.system.IMEConversionMode.JAPANESE_KATAKANA_FULL.</warning>
  <warning id="3520" hidden="true" label="kUnsupportedProp_IME_JAPANESE_KATAKANA_HALF">Místo toho použijte konstantu flash.system.IMEConversionMode.JAPANESE_KATAKANA_HALF.</warning>
  <warning id="3521" hidden="true" label="kUnsupportedProp_IME_KOREAN">Místo toho použijte konstantu flash.system.IMEConversionMode.KOREAN.</warning>
  <warning id="3522" hidden="true" label="kUnsupportedProp_IME_UNKNOWN">Místo toho použijte konstantu flash.system.IMEConversionMode.UNKNOWN.</warning>
  <warning id="3523" hidden="true" label="kUnsupportedMeth_FileReferenceList_addListener">Více informací viz addEventListener ( eventName, listener, useCapture, priority ).</warning>
  <warning id="3524" hidden="true" label="kUnsupportedMeth_FileReferenceList_removeListener">Více informací viz removeEventListener ( eventName, listener, useCapture).</warning>
  <warning id="3527" hidden="true" label="kWarning_Event_onCancel">Ovladač události onCancel není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( cancel, onCancel).</warning>
  <warning id="3528" hidden="true" label="kUnsupportedProp_Keyboard__listeners">Neexistuje žádná přímá náhrada. Pomocí metody willTrigger() lze zjistit, zda byli registrováni nějací posluchači.</warning>
  <warning id="3529" hidden="true" label="kWarning_Event_onIMEComposition">Ovladač události onIMEComposition není v ActionScriptu 3.0 spouštěn Flash Playerem automaticky za běhu. Je nutné nejprve provést registraci tohoto ovladače události pomocí addEventListener ( imeComposition, handlerName).</warning>
  <warning id="3530" hidden="true" label="kUnsupportedProp_SimpleButton__url">Více informací viz LoaderInfo.url a třída Loader.</warning>
  <warning id="3531" hidden="true" label="kUnsupportedMeth_Date_getYear">Místo toho použijte metodu getFullYear().</warning>
  <warning id="3532" hidden="true" label="kUnsupportedMeth_Date_setYear">Místo toho použijte metodu setFullYear().</warning>
  <warning id="3533" hidden="true" label="kUnsupportedMeth_Date_getUTCYear">Místo toho použijte metodu getUTCFullYear().</warning>
  <warning id="3534" hidden="true" label="kUnsupportedMeth_Microphone_setRate">Místo toho použijte vlastnost rate.</warning>
  <warning id="3535" hidden="true" label="kUnsupportedProp_Selection">Třída Selection byla odstraněna. Více informací viz metoda addEventListener třídy, ze které chcete informace o výběru.</warning>
  <warning id="3536" hidden="true" label="kUnsupportedMeth_Selection">Třída Selection byla odstraněna. Více informací viz metoda addEventListener třídy, ze které chcete informace o výběru.</warning>
  <warning id="3537" hidden="true" label="kUnsupportedMeth_Microphone_setGain">Místo toho použijte vlastnost gain.</warning>
  <warning id="3538" hidden="true" label="kUnsupportedMeth_ColorTransform_getTransform">Barevné hodnoty lze přiřadit přímo pomocí konstruktoru nebo vlastností třídy ColorTransform.</warning>
  <warning id="3539" hidden="true" label="kUnsupportedMeth_ColorTransform_setTransform">Barevné hodnoty lze přiřadit přímo pomocí konstruktoru nebo vlastností třídy ColorTransform.</warning>
  <warning id="3540" hidden="true" label="kUnsupportedProp_MovieClip_focusEnabled">Viz nápověda pro vlastnosti třídy flash.display.InteractiveObject, jež se týkají aktivního prvku.</warning>
  <warning id="3541" hidden="true" label="kUnsupportedMeth_MovieClip_beginBitmapFill">Viz nápověda pro metodu flash.display.Graphics.beginBitmapFill.</warning>
  <warning id="3542" hidden="true" label="kUnsupportedMeth_MovieClip_hitTest">Viz nápověda pro metodu flash.display.DisplayObject.hitTestObject().</warning>
  <warning id="3543" hidden="true" label="kUnsupportedMeth_MovieClip_attachBitmap">Viz nápověda pro metodu addChild().</warning>
  <warning id="3544" hidden="true" label="kUnsupportedMeth_Sound_loadSound">Místo toho použijte metodu load().</warning>
  <warning id="3545" hidden="true" label="kUnsupportedMeth_Sound_getVolume">Ke sledování a ovládání amplitudy zvukového kanálu použijte flash.media.SoundChannel.leftPeak a flash.media.SoundChannel.rightPeak.</warning>
  <warning id="3546" hidden="true" label="kUnsupportedMeth_Sound_getTransform">Místo toho použijte vlastnost soundTransform.</warning>
  <warning id="3547" hidden="true" label="kUnsupportedMeth_Sound_getPan">Místo toho použijte vlastnost SoundTransform.pan.</warning>
  <warning id="3548" hidden="true" label="kUnsupportedMeth_Sound_setPan">Místo toho použijte vlastnost SoundTransform.pan.</warning>
  <warning id="3549" hidden="true" label="kUnsupportedMeth_Sound_getBytesLoaded">Místo toho použijte vlastnost bytesLoaded.</warning>
  <warning id="3550" hidden="true" label="kUnsupportedMeth_Sound_getBytesTotal">Místo toho použijte vlastnost bytesTotal.</warning>
  <warning id="3551" hidden="true" label="kWarning_SlowTextFieldAddition">Neefektivní použití += pro TextField.</warning>
  <warning id="3552" label="kWarning_SlowTextFieldAddition_specific">Připojení textu k TextField pomocí += je mnohem pomalejší než použití metody TextField.appendText().
	<description>
		<![CDATA[
		See this language reference for the <code>appendText()</code> method of the TextField class for details on this significant text optimization.
		]]>
	</description>
  </warning>
  <warning id="3553" hidden="true" label="kWarning_UnlikelyFunctionValue">Možná chybí závorky.</warning>
  <warning id="3554" label="kWarning_UnlikelyFunctionValue_specific">Hodnota funkce je použitá na místě, kde byl očekáván typ %s. Za odkazem na tuto funkci možná chybí závorky ().
<description><![CDATA[
You can use functions themselves as values in ActionScript.  The code in question is using a value of type Function where a type other than Function, Object, or * is expected.  Usually,
this indicates a typo where the parentheses <code>()</code> were omitted after the function name.
]]></description>
  </warning>
  
  <warning id="3555" hidden="true" label="kWarning_InstanceOfChanges">Použití operátoru instanceof.</warning>
  <warning id="3556" label="kWarning_InstanceOfChanges_specific">Operátor instanceof není schválen, použijte místo něj operátor is.</warning>
  <warning id="3557" hidden="true" label="kUnsupportedProp_LocalConnection_allowDomain">Ovladač události allowDomain() je nyní standardní metoda, nikoli zpětné volání události. Více informací viz nová metoda LocalConnection.allowDomain.</warning>
  <warning id="3558" hidden="true" label="kUnsupportedProp_LocalConnection_allowInsecureDomain">Ovladač události allowInsecureDomain() je nyní standardní metoda, nikoli zpětné volání události. Více informací viz nová metoda LocalConnection.allowInsecureDomain.</warning>
  <warning id="3559" hidden="true" label="kUnsupportedMeth_call">Globální metoda call() již není podporována.</warning>
  <warning id="3560" hidden="true" label="kUnsupportedProp_Color">Třída Color byla odstraněna. Stejnou funkci plní třída flash.geom.ColorTransform.</warning>
  <warning id="3561" hidden="true" label="kUnsupportedMeth_Color">Třída Color byla odstraněna. Stejnou funkci plní třída flash.geom.ColorTransform.</warning>
  <warning id="3562" hidden="true" label="kUnsupportedProp_System_exactSettings">Soubory SWF ActionScriptu 3.0 vždy používají pravidla pro přesnou shodu domén.</warning>
  <warning id="3563" hidden="true" label="kUnsupportedProp_capabilities">Třída možností byla přejmenována na Capabilities.</warning>
  <warning id="3564" hidden="true" label="kUnsupportedMeth_capabilities">Třída možností byla přejmenována na Capabilities.</warning>
  <warning id="3565" hidden="true" label="kUnsupportedMeth_FileReference_addListener">Pro další informace viz addEventListener(eventName, listener, useCapture, priority ).</warning>
  <warning id="3566" hidden="true" label="kUnsupportedMeth_FileReference_removeListener">Pro další informace viz removeEventListener(eventName, listener, useCapture).</warning>
  <warning id="3567" hidden="true" label="kWarning_Event_onComplete">Zpracování události onComplete není Flash Playerem v ActionScriptu 3.0 za běhu automaticky spuštěno. Nejdříve je nutné toto zpracování pro událost zaregistrovat pomocí addEventListener ('complete', zpracování_zpětného_volání).</warning>
  <warning id="3568" hidden="true" label="kWarning_Event_onHTTPError">Zpracování události onHTTPError není Flash Playerem v ActionScriptu 3.0 za běhu automaticky spuštěno. Nejdříve je nutné toto zpracování pro událost zaregistrovat pomocí addEventListener ('httpError', zpracování_zpětného_volání).</warning>
  <warning id="3569" hidden="true" label="kWarning_Event_onIOError">Zpracování události onIOError není Flash Playerem v ActionScriptu 3.0 za běhu automaticky spuštěno. Nejdříve je nutné toto zpracování pro událost zaregistrovat pomocí addEventListener ('ioError', zpracování_zpětného_volání).</warning>
  <warning id="3570" hidden="true" label="kWarning_Event_onProgress">Zpracování události onProgress není Flash Playerem v ActionScriptu 3.0 za běhu automaticky spuštěno. Nejdříve je nutné toto zpracování pro událost zaregistrovat pomocí addEventListener ('progress', zpracování_zpětného_volání).</warning>
  <warning id="3571" hidden="true" label="kWarning_Event_onSecurityError">Zpracování události onSecurityError není Flash Playerem v ActionScriptu 3.0 za běhu automaticky spuštěno. Nejdříve je nutné toto zpracování pro událost zaregistrovat pomocí addEventListener ('securityError', zpracování_zpětného_volání).</warning>
  <warning id="3572" hidden="true" label="kWarning_Event_onOpen">Zpracování události onOpen není Flash Playerem v ActionScriptu 3.0 za běhu automaticky spuštěno. Nejdříve je nutné toto zpracování pro událost zaregistrovat pomocí addEventListener ('open', zpracování_zpětného_volání).</warning>
  <warning id="3573" hidden="true" label="kWarning_XML_ClassHasChanged">Možné použití třídy XML ActionScriptu 2.0.</warning>
  <warning id="3574" label="kWarning_XML_ClassHasChanged_specific">Problém s přesunutím: Třída XML ActionScriptu 2.0 byla přejmenována na XMLDocument.
	<description>
		<![CDATA[
		This is a code migration warning.  XML is a different class in ActionScript 3.0 than it was in ActionScript 2.0.  In ActionScript 3.0, the XMLDocument class is the equivalent of the XML class in ActionScript 2.0.
The ActionScript 3.0 XML class offers improved functionality with an easier and more powerful API. See XML in the ActionScript Language Reference for additional details.
		]]>
	</description>
  </warning>
  <warning id="3575" hidden="true" label="kWarning_BadDateCast">Neplatná operace přetypování data.</warning>
  <warning id="3576" label="kWarning_BadDateCast_specific">Funkce Date(x) se chová stejně jako nová funkce Date().toString(). Chcete-li vyvolat hodnotu pro vypsání data, použijte "x jako Date" namísto Date(x).</warning>
  
  <warning id="3581" hidden="true" label="kWarning_ImportHidesClass">Importováním balíčku stejného názvu, jako je aktuální třída, se v tomto rozsahu skryje identifikátor dané třídy.</warning>
  <warning id="3582" label="kWarning_ImportHidesClass_specific">Importováním balíčku stejného názvu, jako je aktuální třída, se v tomto rozsahu skryje identifikátor dané třídy.</warning>
  <warning id="3583" hidden="true" label="kWarning_DuplicateArgumentNames">Více argumentů má stejný název.</warning>
  <warning id="3584" label="kWarning_DuplicateArgumentNames_specific">Bylo zadáno více argumentů s názvem '%s'.  Odkazy na daný argument se vždy vztahují na poslední z nich.</warning>
  <warning id="3585" hidden="true" label="kUnsupportedMeth_Rectangle_containsRectangle">Použijte místo toho metodu Rectangle.containsRect.</warning>
  <warning id="3586" hidden="true" label="kUnsupportedMeth_eval">Tato funkce byla odstraněna.</warning>
  <warning id="3587" hidden="true" label="kUnsupportedMeth_getVersion">Tato funkce byla nahrazena vlastností flash.system.Capabilities.version.</warning>
  <warning id="3588" hidden="true" label="kUnsupportedMeth_ifFrameLoaded">Tato funkce byla nahrazena vlastností flash.display.MovieClip.framesLoaded.</warning>
  <warning id="3589" hidden="true" label="kUnsupportedProp__global">Vlastnost _global byla odstraněna.  Pro ekvivalentní funkci použijte statický člen třídy.</warning>
  <warning id="3590" label="kWarning_BadBoolAssignment">Nelogická hodnota použita tam, kde byla očekávána logická hodnota.</warning>
  <warning id="3591" label="kWarning_BadBoolAssignment_specific">Hodnota %s použitá tam, kde byla očekávána logická hodnota.  Výraz bude typem vynucen na logický.</warning>

  <warning id="3592" hidden="true" label="kWarning_BadES3TypeProp">Neznámá vlastnost.</warning>
  <warning id="3593" label="kWarning_BadES3TypeProp_specific">%s není rozpoznaná vlastnost dynamické třídy %s.
	<description>
		<![CDATA[
		The strict compilation mode does not check for undefined properties on instances of dynamic classes.  The types Date, RegExp, and Error are
dynamic for backwards compatibility with ECMAScript.  This warning finds usages of undefined properties on instances of those classes.
A common problem is attempting to get or set a non-existent <code>year</code> property on a Date value.  The correct property name is <code>fullYear</code>.  
		]]>
	</description>  
  </warning>
  
  <warning id="3594" hidden="true" label="kWarning_BadES3TypeMethod">Neznámá metoda.</warning>
  <warning id="3595" label="kWarning_BadES3TypeMethodProp_specific">%s není rozpoznaná metoda dynamické třídy %s.
	<description>
		<![CDATA[
		The strict compilation mode does not check for undefined methods on instances of dynamic classes.  The types Date, RegExp, and Error are
dynamic for backwards compatibility with ECMAScript.  This warning finds usages of undefined methods on instances of those classes. 
		]]>
	</description>
  </warning>

  <warning id="3596" hidden="true" label="kWarning_DuplicateVariableDef">Duplicitní definice proměnné.</warning>
  <warning id="3597" label="kWarning_DuplicateVariableDef_specific">Duplicitní definice proměnné.
	<description>
		<![CDATA[
		The compiler has detected a duplicate definition for a variable.  This can lead to unexpected results.  ActionScript does not support block level 
		scoping of variables.  All variables defined within a function body exist within the same scope, even if they are defined within an 
		<code>if</code> statement, <code>while</code> statement, <code>for</code> statement, and so on: for example, the following code redeclares the variable x twice:
		
		<pre><code>
function test() {
	var x:Number = 10;
	if (true) {
	    for (var x=0; x &lt 5; x++)  // warning here, this is the second defintion of x
	    trace(x);
	}
	trace(x); // 5, not 10.  The last value set by the for loop above is the current value of x
}</pre></code>	
		]]>
	</description>
  </warning>
  <warning id="3598" label="kWarning_DefinitionShadowedByPackageName">Název definice je stejný jako název importovaného balíčku. Nekvalifikované odkazy na tento název povedou na příslušný balíček a ne na definici.</warning>
  <warning id="3599" label="kWarning_DefinitionShadowedByPackageName_specific">Název definice je stejný jako název importovaného balíčku. Nekvalifikované odkazy na tento název povedou na příslušný balíček a ne na definici.
	<description>
		<![CDATA[
        If a definition is named the same as a package that is in scope, then any unqualified references to that name will resolve to the package instead of the definition.  This can
        result in unexpected errors when attempting to reference the variable.  Any references to the definition need to be qualified to resolve to the definition and not the package.
        ]]>
	</description>
  </warning>
  <warning id="3600" label="kWarning_DeleteOfFixedProperty">Možný pokus o odstranění pevné vlastnosti.</warning>
  <warning id="3601" label="kWarning_DeleteOfFixedProperty_specific">Deklarovanou vlastnost %s nelze odstranit. Chcete-li uvolnit přiřazenou paměť, nastavte její hodnotu na null. 
     <description>Delete removes dynamically defined properties from an object.  Declared properties of a class can not be deleted, the operation merely fails silently.  To free memory associated with this variable, set its value to null instead.</description>
  </warning>


</warnings>

<properties>
	<unsupported label="kUnsupportedProp_version">
		<baseType>kVoidType</baseType>
		<propName>$version</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_Focusrect">
		<baseType>kVoidType</baseType>
		<propName>_focusrect</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp__global">
		<baseType>kVoidType</baseType>
		<propName>_global</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_Highquality">
		<baseType>kVoidType</baseType>
		<propName>_highquality</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_DisplayObj_HighQuality">
		<baseType>kDisplayObjectType</baseType>
		<propName>_highquality</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_DisplayObj_Quality">
		<baseType>kDisplayObjectType</baseType>
		<propName>_quality</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_Quality">
		<baseType>kVoidType</baseType>
		<propName>_quality</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_TextField_Soundbuftime">
		<baseType>kTextFieldType</baseType>
		<propName>_soundbuftime</propName>
		<isStatic>false</isStatic>
	</unsupported>
	
	<unsupported label="kUnsupportedProp_TextField_Target">
		<baseType>kTextFieldType</baseType>
		<propName>_target</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_TextField_Url">
		<baseType>kTextFieldType</baseType>
		<propName>_url</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_TextField_Variable">
		<baseType>kTextFieldType</baseType>
		<propName>variable</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<!-- removed unsupported label="kUnsupportedProp_TextFormat_Color">
		<baseType>kTextFormatType</baseType>
		<propName>color</propName>
		<isStatic>false</isStatic>
	</unsupported -->
	<unsupported label="kUnsupportedProp_NewLine">
		<baseType>kVoidType</baseType>
		<propName>newline</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_MaxScroll">
		<baseType>kVoidType</baseType>
		<propName>maxscroll</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_Level">
		<baseType>kVoidType</baseType>
		<propName>_level</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_Parent">
		<baseType>kVoidType</baseType>
		<propName>_parent</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_Root">
		<baseType>kVoidType</baseType>
		<propName>_root</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_Arguments_Caller">
		<baseType>kArrayType</baseType>
		<propName>caller</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_Button_Target">
		<baseType>kDisplayObjectType</baseType>
		<propName>_target</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_MovieClip_Parent">
		<baseType>kDisplayObjectType</baseType>
		<propName>_parent</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_MovieClip_target">
		<baseType>kDisplayObjectType</baseType>
		<propName>_target</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_MovieClip_hitArea">
		<baseType>kDisplayObjectType</baseType>
		<propName>hitArea</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_Scroll">
		<baseType>kVoidType</baseType>
		<propName>scroll</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_TargetPath">
		<baseType>kVoidType</baseType>
		<propName>targetPath</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_Video_Height">
		<baseType>kVideoType</baseType>
		<propName>height</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_Video_Width">
		<baseType>kVideoType</baseType>
		<propName>width</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp__Proto__">
		<baseType>kObjectType</baseType>
		<propName>__proto__</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_Stage">
		<baseType>kVoidType</baseType>
		<propName>Stage</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp__remoteClass">
		<baseType>kObjectType</baseType>
		<propName>_remoteClass</propName>
		<isStatic>false</isStatic>
	</unsupported>
	
	<unsupported label="kUnsupportedProp_ActivityEvent_ACTIVITY_TYPE" classProp="true">
      <baseType>kActivityEventType</baseType>
      <propName>ACTIVITY_TYPE</propName>
       <isStatic>true</isStatic>
     </unsupported>
    <unsupported label="kUnsupportedProp_Camera_currentFps">
      <baseType>kCameraType</baseType>
      <propName>currentFps</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_ContextMenu_forward_back">
      <baseType>kContextMenuType</baseType>
      <propName>forward_back</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DataEvent_DATA_TYPE" classProp="true">
      <baseType>kDataEventType</baseType>
      <propName>DATA_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject_xscale">
      <baseType>kDisplayObjectType</baseType>
      <propName>xscale</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject__xscale">
      <baseType>kDisplayObjectType</baseType>
      <propName>_xscale</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject_yscale">
      <baseType>kDisplayObjectType</baseType>
      <propName>yscale</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject__yscale">
      <baseType>kDisplayObjectType</baseType>
      <propName>_yscale</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject_xmouse">
      <baseType>kDisplayObjectType</baseType>
      <propName>xmouse</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject__xmouse">
      <baseType>kDisplayObjectType</baseType>
      <propName>_xmouse</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject_ymouse">
      <baseType>kDisplayObjectType</baseType>
      <propName>ymouse</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject__ymouse">
      <baseType>kDisplayObjectType</baseType>
      <propName>_ymouse</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject_setRootClass">
      <baseType>kDisplayObjectType</baseType>
      <propName>setRootClass</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject_mapSymbolToClass">
      <baseType>kDisplayObjectType</baseType>
      <propName>mapSymbolToClass</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject__name">
      <baseType>kDisplayObjectType</baseType>
      <propName>_name</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject__parent">
      <baseType>kDisplayObjectType</baseType>
      <propName>_parent</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject__mask">
      <baseType>kDisplayObjectType</baseType>
      <propName>_mask</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject__visible">
      <baseType>kDisplayObjectType</baseType>
      <propName>_visible</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject__x">
      <baseType>kDisplayObjectType</baseType>
      <propName>_x</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject__y">
      <baseType>kDisplayObjectType</baseType>
      <propName>_y</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject__rotation">
      <baseType>kDisplayObjectType</baseType>
      <propName>_rotation</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject__alpha">
      <baseType>kDisplayObjectType</baseType>
      <propName>_alpha</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject__width">
      <baseType>kDisplayObjectType</baseType>
      <propName>_width</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_DisplayObject__height">
      <baseType>kDisplayObjectType</baseType>
      <propName>_height</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_ErrorEvent_ERROR_TYPE" classProp="true">
      <baseType>kErrorEventType</baseType>
      <propName>ERROR_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_ACTIVATE_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>ACTIVATE_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_ADDED_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>ADDED_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_CANCEL_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>CANCEL_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_CHANGE_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>CHANGE_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_CLOSE_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>CLOSE_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_COMPLETE_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>COMPLETE_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_CONNECT_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>CONNECT_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_DEACTIVATE_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>DEACTIVATE_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_ENTER_FRAME_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>ENTER_FRAME_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_ID3_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>ID3_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_INIT_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>INIT_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_MOUSE_LEAVE_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>MOUSE_LEAVE_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_OPEN_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>OPEN_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_REMOVED_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>REMOVED_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_RENDER_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>RENDER_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_RESIZE_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>RESIZE_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_SCROLL_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>SCROLL_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_SELECT_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>SELECT_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_SOUND_COMPLETE_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>SOUND_COMPLETE_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_TAB_CHILDREN_CHANGE_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>TAB_CHILDREN_CHANGE_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_TAB_ENABLED_CHANGE_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>TAB_ENABLED_CHANGE_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_TAB_INDEX_CHANGE_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>TAB_INDEX_CHANGE_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Event_UNLOAD_TYPE" classProp="true">
      <baseType>kEventType</baseType>
      <propName>UNLOAD_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_FocusEvent_FOCUS_IN_TYPE" classProp="true">
      <baseType>kFocusEventType</baseType>
      <propName>FOCUS_IN_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_FocusEvent_FOCUS_OUT_TYPE" classProp="true">
      <baseType>kFocusEventType</baseType>
      <propName>FOCUS_OUT_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_FocusEvent_KEY_FOCUS_CHANGE_TYPE" classProp="true">
      <baseType>kFocusEventType</baseType>
      <propName>KEY_FOCUS_CHANGE_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_FocusEvent_MOUSE_FOCUS_CHANGE_TYPE" classProp="true">
      <baseType>kFocusEventType</baseType>
      <propName>MOUSE_FOCUS_CHANGE_TYPE</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_BitmapFilter_XYZ_QUALITY">
      <baseType>kBitmapFilterType</baseType>
      <propName>XYZ_QUALITY</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Keyboard_PGDN" classProp="true">
      <baseType>kKeyboardType</baseType>
      <propName>PGDN</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Keyboard_PGUP" classProp="true">
      <baseType>kKeyboardType</baseType>
      <propName>PGUP</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Keyboard_DELETEKEY" classProp="true">
      <baseType>kKeyboardType</baseType>
      <propName>DELETEKEY</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Keyboard_CAPSLOCK" classProp="true">
      <baseType>kKeyboardType</baseType>
      <propName>CAPSLOCK</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Keyboard_NUMPAD" classProp="true">
      <baseType>kKeyboardType</baseType>
      <propName>NUMPAD</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_InteractiveObject__focusrect">
      <baseType>kInteractiveObjectType</baseType>
      <propName>_focusrect</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_InteractiveObject_menu">
      <baseType>kInteractiveObjectType</baseType>
      <propName>menu</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_KeyboardEvent_ascii">
      <baseType>kKeyboardEventType</baseType>
      <propName>ascii</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_KeyboardEvent_code">
      <baseType>kKeyboardEventType</baseType>
      <propName>code</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Loader_loaderInfo">
      <baseType>kLoaderType</baseType>
      <propName>loaderInfo</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Loader_preload">
      <baseType>kLoaderType</baseType>
      <propName>preload</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Loader_loadCached">
      <baseType>kLoaderType</baseType>
      <propName>loadCached</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_LoaderInfo_loaderUrl">
      <baseType>kLoaderInfoType</baseType>
      <propName>loaderUrl</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_ContextMenuEvent_menuOwner">
      <baseType>kContextMenuEventType</baseType>
      <propName>menuOwner</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_MovieClip_url">
      <baseType>kMovieClipType</baseType>
      <propName>url</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_MovieClip__url">
      <baseType>kMovieClipType</baseType>
      <propName>_url</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_MovieClip__currentframe">
      <baseType>kMovieClipType</baseType>
      <propName>_currentframe</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_MovieClip__framesloaded">
      <baseType>kMovieClipType</baseType>
      <propName>_framesloaded</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_MovieClip__totalframes">
      <baseType>kMovieClipType</baseType>
      <propName>_totalframes</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_MovieClip_lockroot">
      <baseType>kMovieClipType</baseType>
      <propName>lockroot</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_MovieClip__lockroot">
      <baseType>kMovieClipType</baseType>
      <propName>_lockroot</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_MovieClip__soundbuftime">
      <baseType>kMovieClipType</baseType>
      <propName>_soundbuftime</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_NetStream_currentFps">
      <baseType>kNetStreamType</baseType>
      <propName>currentFps</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_NetStream_videocodec">
      <baseType>kNetStreamType</baseType>
      <propName>videocodec</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_NetStream_audiocodec">
      <baseType>kNetStreamType</baseType>
      <propName>audiocodec</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Proxy_delDescendants">
      <baseType>kProxyType</baseType>
      <propName>delDescendants</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_ProgressEvent_current">
      <baseType>kProgressEventType</baseType>
      <propName>current</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_ProgressEvent_total">
      <baseType>kProgressEventType</baseType>
      <propName>total</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Sprite__droptarget">
      <baseType>kSpriteType</baseType>
      <propName>_droptarget</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Stage_showMenu">
      <baseType>kStageType</baseType>
      <propName>showMenu</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_StyleSheet_loaded">
      <baseType>kStyleSheetType</baseType>
      <propName>loaded</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_System_getAvmplusVersion">
      <baseType>kSystemType</baseType>
      <propName>getAvmplusVersion</propName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_SWFLoaderInfo_SWFVersion">
      <baseType>kSWFLoaderInfoType</baseType>
      <propName>SWFVersion</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_SWFLoaderInfo_ASVersion">
      <baseType>kSWFLoaderInfoType</baseType>
      <propName>ASVersion</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_TextField_maxscroll">
      <baseType>kTextFieldType</baseType>
      <propName>maxscroll</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_TextField_hscroll">
      <baseType>kTextFieldType</baseType>
      <propName>hscroll</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_TextField_maxhscroll">
      <baseType>kTextFieldType</baseType>
      <propName>maxhscroll</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_TextField_newTextFormat">
      <baseType>kTextFieldType</baseType>
      <propName>newTextFormat</propName>
      <isStatic>false</isStatic>
    </unsupported>

    <unsupported label="kUnsupportedProp_URLLoader_navigate">
      <baseType>kURLLoaderType</baseType>
      <propName>navigate</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_URLLoader_binary">
      <baseType>kURLLoaderType</baseType>
      <propName>binary</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_URLRequest_digest">
      <baseType>kURLRequestType</baseType>
      <propName>digest</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_URLRequest_importToSandbox">
      <baseType>kURLRequestType</baseType>
      <propName>importToSandbox</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_XMLDocument_loaded">
      <baseType>kXMLDocumentType</baseType>
      <propName>loaded</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_XMLDocument_contentType">
      <baseType>kXMLDocumentType</baseType>
      <propName>contentType</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_XMLDocument_status">
      <baseType>kXMLDocumentType</baseType>
      <propName>status</propName>
      <isStatic>false</isStatic>
    </unsupported>

    <unsupported label="kUnsupportedProp_Button">
      <baseType>kVoidType</baseType>
      <propName>Button</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Container">
      <baseType>kVoidType</baseType>
      <propName>Container</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Image">
      <baseType>kVoidType</baseType>
      <propName>Image</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_ImageFilter">
      <baseType>kVoidType</baseType>
      <propName>ImageFilter</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_ImageSprite">
      <baseType>kVoidType</baseType>
      <propName>ImageSprite</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_ImageLoaderInfo">
      <baseType>kVoidType</baseType>
      <propName>ImageLoaderInfo</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_ImeEvent">
      <baseType>kVoidType</baseType>
      <propName>ImeEvent</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Key">
      <baseType>kVoidType</baseType>
      <propName>Key</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_LineMetrics">
      <baseType>kVoidType</baseType>
      <propName>LineMetrics</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_LoadVars">
      <baseType>kVoidType</baseType>
      <propName>LoadVars</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_MenuEvent">
      <baseType>kVoidType</baseType>
      <propName>MenuEvent</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_MovieClipLoader">
      <baseType>kVoidType</baseType>
      <propName>MovieClipLoader</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_SystemCapabilities">
      <baseType>kVoidType</baseType>
      <propName>SystemCapabilities</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_SystemCapabilities">
      <baseType>kVoidType</baseType>
      <propName>SystemCapabilities</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_TextExtents">
      <baseType>kVoidType</baseType>
      <propName>TextExtents</propName>
      <isStatic>false</isStatic>
    </unsupported>
    
    <unsupported label="kUnsupportedProp_TextExtents">
      <baseType>kVoidType</baseType>
      <propName>TextExtents</propName>
      <isStatic>false</isStatic>
    </unsupported>
    
    <unsupported label="kUnsupportedProp_DisplayObject_accProps">
      <baseType>kDisplayObjectType</baseType>
      <propName>accProps</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_NetConnection_isConnected">
      <baseType>kNetConnectionType</baseType>
      <propName>isConnected</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_Socket_isConnected">
      <baseType>kSocketType</baseType>
      <propName>isConnected</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_URLStream_isConnected">
      <baseType>kURLStreamType</baseType>
      <propName>isConnected</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_SyncEvent_list">
      <baseType>kSyncEventType</baseType>
      <propName>list</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_TextField_scroll">
      <baseType>kTextFieldType</baseType>
      <propName>scroll</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_TextField_bottomScroll">
      <baseType>kTextFieldType</baseType>
      <propName>bottomScroll</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_BitmapData_RED_CHANNEL">
      <baseType>kBitmapDataType</baseType>
      <propName>RED_CHANNEL</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_BitmapData_GREEN_CHANNEL">
      <baseType>kBitmapDataType</baseType>
      <propName>GREEN_CHANNEL</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_BitmapData_BLUE_CHANNEL">
      <baseType>kBitmapDataType</baseType>
      <propName>BLUE_CHANNEL</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_BitmapData_ALPHA_CHANNEL">
      <baseType>kBitmapDataType</baseType>
      <propName>ALPHA_CHANNEL</propName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedProp_System_useCodepage">
      <baseType>kSystemType</baseType>
      <propName>useCodepage</propName>
      <isStatic>true</isStatic>
    </unsupported>
	<unsupported label="kUnsupportedProp_SimpleButton_Soundbuftime">
		<baseType>kSimpleButtonType</baseType>
		<propName>_soundbuftime</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_AsBroadcaster">
		<baseType>kVoidType</baseType>
		<propName>AsBroadcaster</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_IME_ALPHANUMERIC_FULL">
		<baseType>kIMEType</baseType>
		<propName>ALPHANUMERIC_FULL</propName>
		<isStatic>true</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_IME_ALPHANUMERIC_HALF">
		<baseType>kIMEType</baseType>
		<propName>ALPHANUMERIC_HALF</propName>
		<isStatic>true</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_IME_CHINESE">
		<baseType>kIMEType</baseType>
		<propName>CHINESE</propName>
		<isStatic>true</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_IME_JAPANESE_HIRAGANA">
		<baseType>kIMEType</baseType>
		<propName>JAPANESE_HIRAGANA</propName>
		<isStatic>true</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_IME_JAPANESE_KATAKANA_FULL">
		<baseType>kIMEType</baseType>
		<propName>JAPANESE_KATAKANA_FULL</propName>
		<isStatic>true</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_IME_JAPANESE_KATAKANA_HALF">
		<baseType>kIMEType</baseType>
		<propName>JAPANESE_KATAKANA_HALF</propName>
		<isStatic>true</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_IME_KOREAN">
		<baseType>kIMEType</baseType>
		<propName>KOREAN</propName>
		<isStatic>true</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_IME_UNKNOWN">
		<baseType>kIMEType</baseType>
		<propName>UNKNOWN</propName>
		<isStatic>true</isStatic>
	</unsupported>	
	<unsupported label="kUnsupportedProp_Keyboard__listeners">
		<baseType>kKeyboardType</baseType>
		<propName>_listeners</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_SimpleButton__url">
		<baseType>kSimpleButtonType</baseType>
		<propName>_url</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_Selection">
		<baseType>kVoidType</baseType>
		<propName>Selection</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_MovieClip_focusEnabled">
		<baseType>kDisplayObjectType</baseType>
		<propName>focusEnabled</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_LocalConnection_allowDomain">
		<baseType>kLocalConnectionType</baseType>
		<propName>allowDomain</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_LocalConnection_allowInsecureDomain">
		<baseType>kLocalConnectionType</baseType>
		<propName>allowInsecureDomain</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_Color">
		<baseType>kVoidType</baseType>
		<propName>Color</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_System_exactSettings">
		<baseType>kSystemType</baseType>
		<propName>exactSettings</propName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedProp_capabilities">
		<baseType>kVoidType</baseType>
		<propName>capabilities</propName>
		<isStatic>false</isStatic>
	</unsupported>	
	<unsupported label="kUnsupportedProp_Object___resolve">
		<baseType>kObjectType</baseType>
		<propName>__resolve</propName>
		<isStatic>false</isStatic>
	</unsupported>
</properties>

	
<methods>
   <unsupported label="kUnsupportedMeth_instanceof">
		<baseType>kVoidType</baseType>
		<methodName>instanceof</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_DisplayObject_setScalingGrid">
		<baseType>kDisplayObjectType</baseType>
		<methodName>setScalingGrid</methodName>
		<isStatic>false</isStatic>
	</unsupported>	
	<unsupported label="kUnsupportedMeth_Graphics_drawCircle">
		<baseType>kGraphicsType</baseType>
		<methodName>drawCircle</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_XMLUI_get">
		<baseType>kXMLUIType</baseType>
		<methodName>get</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_XMLUI_set">
		<baseType>kXMLUIType</baseType>
		<methodName>set</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_hasChildNodes">
		<baseType>kXMLNodeType</baseType>
		<methodName>hasChildNodes</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_XMLEvent">
		<baseType>kVoidType</baseType>
		<methodName>XMLEvent</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_XMLDoc">
		<baseType>kVoidType</baseType>
		<methodName>XMLDoc</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_random">
		<baseType>kVoidType</baseType>
		<methodName>random</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_chr">
		<baseType>kVoidType</baseType>
		<methodName>chr</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_mbchr">
		<baseType>kVoidType</baseType>
		<methodName>mbchr</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<!-- removed unsupported label="kUnsupportedMeth_int">
		<baseType>kVoidType</baseType>
		<methodName>int</methodName>
		<isStatic>false</isStatic>
	</unsupported -->
	<unsupported label="kUnsupportedMeth_ord">
		<baseType>kVoidType</baseType>
		<methodName>ord</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_mbord">
		<baseType>kVoidType</baseType>
		<methodName>mbord</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_substring">
		<baseType>kVoidType</baseType>
		<methodName>substring</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_mbsubstring">
		<baseType>kVoidType</baseType>
		<methodName>mbsubstring</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_length">
		<baseType>kVoidType</baseType>
		<methodName>length</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_mblength">
		<baseType>kVoidType</baseType>
		<methodName>mblength</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_ASNative">
		<baseType>kVoidType</baseType>
		<methodName>ASnative</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_addProperty">
		<baseType>kObjectType</baseType>
		<methodName>addProperty</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_getProperty">
		<baseType>kVoidType</baseType>
		<methodName>getProperty</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_setProperty">
		<baseType>kVoidType</baseType>
		<methodName>setProperty</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_asfunction">
		<baseType>kVoidType</baseType>
		<methodName>asfunction</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<!--unsupported label="kUnsupportedMeth_Function_call">
		<baseType>kFunctionType</baseType>
		<methodName>call</methodName>
		<isStatic>false</isStatic>
	</unsupported-->
	<unsupported label="kUnsupportedMeth_clearInterval">
		<baseType>kVoidType</baseType>
		<methodName>clearInterval</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_duplicateMovieClip">
		<baseType>kVoidType</baseType>
		<methodName>duplicateMovieClip</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_fscommand">
		<baseType>kVoidType</baseType>
		<methodName>fscommand</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_getURL">
		<baseType>kVoidType</baseType>
		<methodName>getURL</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_gotoAndPlay">
		<baseType>kVoidType</baseType>
		<methodName>gotoAndPlay</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_gotoAndStop">
		<baseType>kVoidType</baseType>
		<methodName>gotoAndStop</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_play">
		<baseType>kVoidType</baseType>
		<methodName>play</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_print">
		<baseType>kVoidType</baseType>
		<methodName>print</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_printAsBitmap">
		<baseType>kVoidType</baseType>
		<methodName>printAsBitmap</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_printAsBitmapNum">
		<baseType>kVoidType</baseType>
		<methodName>printAsBitmapNum</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_printNum">
		<baseType>kVoidType</baseType>
		<methodName>printNum</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_removeMovieClip">
		<baseType>kVoidType</baseType>
		<methodName>removeMovieClip</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_setInterval">
		<baseType>kVoidType</baseType>
		<methodName>setInterval</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_nextFrame">
		<baseType>kVoidType</baseType>
		<methodName>nextFrame</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_startDrag">
		<baseType>kVoidType</baseType>
		<methodName>startDrag</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_stop">
		<baseType>kVoidType</baseType>
		<methodName>stop</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_stopAllSounds">
		<baseType>kVoidType</baseType>
		<methodName>stopAllSounds</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_stopDrag">
		<baseType>kVoidType</baseType>
		<methodName>stopDrag</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_tellTarget">
		<baseType>kVoidType</baseType>
		<methodName>tellTarget</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_toggleHighQuality">
		<baseType>kVoidType</baseType>
		<methodName>toggleHighQuality</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<!-- unsupported label="kUnsupportedMeth_unescape">
		<baseType>kVoidType</baseType>
		<methodName>unescape</methodName>
		<isStatic>false</isStatic>
	</unsupported -->
	<unsupported label="kUnsupportedMeth_unloadMovie">
		<baseType>kVoidType</baseType>
		<methodName>unloadMovie</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_unloadMovieNum">
		<baseType>kVoidType</baseType>
		<methodName>unloadMovieNum</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_updateAfterEvent">
		<baseType>kVoidType</baseType>
		<methodName>updateAfterEvent</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Video_attachVideo">
		<baseType>kVideoType</baseType>
		<methodName>attachVideo</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_TextField_StyleSheet_load">
		<baseType>kStyleSheetType</baseType>
		<methodName>load</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<!-- removed unsupported label="kUnsupportedMeth_TextField_StyleSheet_parseCSS">
		<baseType>kStyleSheetType</baseType>
		<methodName>parseCSS</methodName>
		<isStatic>false</isStatic>
	</unsupported -->
	<!-- removed unsupported label="kUnsupportedMeth_TextField_StyleSheet_setStyle">
		<baseType>kStyleSheetType</baseType>
		<methodName>setStyle</methodName>
		<isStatic>false</isStatic>
	</unsupported -->
	<unsupported label="kUnsupportedMeth_Object_registerClass">
		<baseType>kObjectType</baseType>
		<methodName>registerClass</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Object_unwatch">
		<baseType>kObjectType</baseType>
		<methodName>unwatch</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Object_watch">
		<baseType>kObjectType</baseType>
		<methodName>watch</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_loadMovie">
		<baseType>kVoidType</baseType>
		<methodName>loadMovie</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_loadMovieNum">
		<baseType>kVoidType</baseType>
		<methodName>loadMovieNum</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_loadVariables">
		<baseType>kVoidType</baseType>
		<methodName>loadVariables</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_loadVariablesNum">
		<baseType>kVoidType</baseType>
		<methodName>loadVariablesNum</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<!-- removed unsupported label="kUnsupportedMeth_Selection_getBeginIndex">
		<baseType>kSelectionType</baseType>
		<methodName>getBeginIndex</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Selection_getCaretIndex">
		<baseType>kSelectionType</baseType>
		<methodName>getCaretIndex</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Selection_getEndIndex">
		<baseType>kSelectionType</baseType>
		<methodName>getEndIndex</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Selection_getFocus">
		<baseType>kSelectionType</baseType>
		<methodName>getFocus</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Selection_setFocus">
		<baseType>kSelectionType</baseType>
		<methodName>setFocus</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Selection_setSelection">
		<baseType>kSelectionType</baseType>
		<methodName>setSelection</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Selection_addListener">
		<baseType>kSelectionType</baseType>
		<methodName>addListener</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Selection_removeListener">
		<baseType>kSelectionType</baseType>
		<methodName>removeListener</methodName>
		<isStatic>false</isStatic>
	</unsupported -->
	<unsupported label="kUnsupportedMeth_Stage_addListener">
		<baseType>kStageType</baseType>
		<methodName>addListener</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Stage_removeListener">
		<baseType>kStageType</baseType>
		<methodName>removeListener</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_TextField_addListener">
		<baseType>kTextFieldType</baseType>
		<methodName>addListener</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_TextField_removeListener">
		<baseType>kTextFieldType</baseType>
		<methodName>removeListener</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Mouse_addListener">
		<baseType>kMouseType</baseType>
		<methodName>addListener</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Mouse_removeListener">
		<baseType>kMouseType</baseType>
		<methodName>removeListener</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Keyboard_addListener">
		<baseType>kKeyboardType</baseType>
		<methodName>addListener</methodName>
		<isStatic>true</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Keyboard_removeListener">
		<baseType>kKeyboardType</baseType>
		<methodName>removeListener</methodName>
		<isStatic>true</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Sound_attachSound">
		<baseType>kSoundType</baseType>
		<methodName>attachSound</methodName>
		<isStatic>false</isStatic>
	</unsupported>
    <unsupported label="kUnsupportedMeth_Accessibility_isActive">
      <baseType>kAccessibilityType</baseType>
      <methodName>isActive</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_SimpleButton_getDepth">
      <baseType>kSimpleButtonType</baseType>
      <methodName>getDepth</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_SimpleButton_swapDepths">
      <baseType>kSimpleButtonType</baseType>
      <methodName>swapDepths</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_SimpleButton_getInstanceAtDepth">
      <baseType>kSimpleButtonType</baseType>
      <methodName>getInstanceAtDepth</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_SimpleButton_getNextHighestDepth">
      <baseType>kSimpleButtonType</baseType>
      <methodName>getNextHighestDepth</methodName>
    <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_ByteArray_available">
      <baseType>kByteArrayType</baseType>
      <methodName>available</methodName>
       <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_ByteArray_getFilePointer">
      <baseType>kByteArrayType</baseType>
      <methodName>getFilePointer</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_ByteArray_seek">
      <baseType>kByteArrayType</baseType>
      <methodName>seek</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Camera_get">
      <baseType>kCameraType</baseType>
      <methodName>get</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Camera_setKeyFrameInterval">
      <baseType>kCameraType</baseType>
      <methodName>setKeyFrameInterval</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Camera_setLoopback">
      <baseType>kCameraType</baseType>
      <methodName>setLoopback</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_ColorTransform_getRGB">
      <baseType>kColorTransformType</baseType>
      <methodName>getRGB</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_ColorTransform_setRGB">
      <baseType>kColorTransformType</baseType>
      <methodName>setRGB</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_DisplayObjectContainer_getTextSnapshot">
      <baseType>kDisplayObjectContainerType</baseType>
      <methodName>getTextSnapshot</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_ContextMenu_copy">
      <baseType>kContextMenuType</baseType>
      <methodName>copy</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_ContextMenuItem_copy">
      <baseType>kContextMenuItemType</baseType>
      <methodName>copy</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_CustomActions_listActions">
      <baseType>kCustomActionsType</baseType>
      <methodName>listActions</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_ExternalInterface_available">
      <baseType>kExternalInterfaceType</baseType>
      <methodName>available</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Event_isDefaultPrevented">
      <baseType>kEventType</baseType>
      <methodName>isDefaultPrevented</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Graphics_beginImageFill">
      <baseType>kGraphicsType</baseType>
      <methodName>beginImageFill</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Keyboard_getAscii">
      <baseType>kKeyboardType</baseType>
      <methodName>getAscii</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Keyboard_getCode">
      <baseType>kKeyboardType</baseType>
      <methodName>getCode</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Keyboard_isDown">
      <baseType>kKeyboardType</baseType>
      <methodName>isDown</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Keyboard_isToggled">
      <baseType>kKeyboardType</baseType>
      <methodName>isToggled</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_LocalConnection_domain">
      <baseType>kLocalConnectionType</baseType>
      <methodName>domain</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Microphone_get">
      <baseType>kMicrophoneType</baseType>
      <methodName>get</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_attachMovie">
      <baseType>kMovieClipType</baseType>
      <methodName>attachMovie</methodName>
      <isStatic>false</isStatic>
    </unsupported>    
    <unsupported label="kUnsupportedMeth_MovieClip_createEmptyMovieClip">
      <baseType>kMovieClipType</baseType>
      <methodName>createEmptyMovieClip</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_createTextField">
      <baseType>kMovieClipType</baseType>
      <methodName>createTextField</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_removeMovieClip">
      <baseType>kMovieClipType</baseType>
      <methodName>removeMovieClip</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_loadMovie">
      <baseType>kMovieClipType</baseType>
      <methodName>loadMovie</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_unloadMovie">
      <baseType>kMovieClipType</baseType>
      <methodName>unloadMovie</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_unloadMovieNum">
      <baseType>kMovieClipType</baseType>
      <methodName>unloadMovieNum</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_getDepth">
      <baseType>kMovieClipType</baseType>
      <methodName>getDepth</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_swapDepths">
      <baseType>kMovieClipType</baseType>
      <methodName>swapDepths</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_getInstanceAtDepth">
      <baseType>kMovieClipType</baseType>
      <methodName>getInstanceAtDepth</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_getNextHighestDepth">
      <baseType>kMovieClipType</baseType>
      <methodName>getNextHighestDepth</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_attachAudio">
      <baseType>kMovieClipType</baseType>
      <methodName>attachAudio</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_getBytesLoaded">
      <baseType>kMovieClipType</baseType>
      <methodName>getBytesLoaded</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_getBytesTotal">
      <baseType>kMovieClipType</baseType>
      <methodName>getBytesTotal</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_getURL">
      <baseType>kMovieClipType</baseType>
      <methodName>getURL</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_setMask">
      <baseType>kMovieClipType</baseType>
      <methodName>setMask</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_getSWFVersion">
      <baseType>kMovieClipType</baseType>
      <methodName>getSWFVersion</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_clear">
      <baseType>kMovieClipType</baseType>
      <methodName>clear</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_beginFill">
      <baseType>kMovieClipType</baseType>
      <methodName>beginFill</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_beginGradientFill">
      <baseType>kMovieClipType</baseType>
      <methodName>beginGradientFill</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_lineGradientStyle">
      <baseType>kMovieClipType</baseType>
      <methodName>lineGradientStyle</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_beginImageFill">
      <baseType>kMovieClipType</baseType>
      <methodName>beginImageFill</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_lineStyle">
      <baseType>kMovieClipType</baseType>
      <methodName>lineStyle</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_drawRect">
      <baseType>kMovieClipType</baseType>
      <methodName>drawRect</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_drawRoundRect">
      <baseType>kMovieClipType</baseType>
      <methodName>drawRoundRect</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_drawRoundRectComplex">
      <baseType>kMovieClipType</baseType>
      <methodName>drawRoundRectComplex</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_drawCircle">
      <baseType>kMovieClipType</baseType>
      <methodName>drawCircle</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_moveTo">
      <baseType>kMovieClipType</baseType>
      <methodName>moveTo</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_lineTo">
      <baseType>kMovieClipType</baseType>
      <methodName>lineTo</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_curveTo">
      <baseType>kMovieClipType</baseType>
      <methodName>curveTo</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_endFill">
      <baseType>kMovieClipType</baseType>
      <methodName>endFill</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_NetStream_setBufferTime">
      <baseType>kNetStreamType</baseType>
      <methodName>setBufferTime</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_ProductManager_isIntalled">
      <baseType>kProductManagerType</baseType>
      <methodName>isIntalled</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_ProductManager_installedVersion">
      <baseType>kProductManagerType</baseType>
      <methodName>installedVersion</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_ProductManager_isRunning">
      <baseType>kProductManagerType</baseType>
      <methodName>isRunning</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Point_addTo">
      <baseType>kPointType</baseType>
      <methodName>addTo</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Profiler_heapdump">
      <baseType>kVoidType</baseType>
      <methodName>heapdump</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Rectangle_isEmpty">
      <baseType>kRectangleType</baseType>
      <methodName>isEmpty</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Rectangle_containsRectangle">
      <baseType>kRectangleType</baseType>
      <methodName>containsRectangle</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_SoundTransform_setPan">
      <baseType>kSoundTransformType</baseType>
      <methodName>setPan</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Socket_available">
      <baseType>kSocketType</baseType>
      <methodName>available</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_SharedObject_getSize">
      <baseType>kSharedObjectType</baseType>
      <methodName>getSize</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_SharedObject_setFps">
      <baseType>kSharedObjectType</baseType>
      <methodName>setFps</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Sprite_getSWF">
      <baseType>kSpriteType</baseType>
      <methodName>getSWF</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Sprite_constructChild">
      <baseType>kSpriteType</baseType>
      <methodName>constructChild</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Stage_getFocus">
      <baseType>kStageType</baseType>
      <methodName>getFocus</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Stage_setFocus">
      <baseType>kStageType</baseType>
      <methodName>setFocus</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_StyleSheet_getStyleNames">
      <baseType>kStyleSheetType</baseType>
      <methodName>getStyleNames</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_StyleSheet_onData">
      <baseType>kStyleSheetType</baseType>
      <methodName>onData</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_StyleSheet_load">
      <baseType>kStyleSheetType</baseType>
      <methodName>load</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_StyleSheet_getBytesLoaded">
      <baseType>kStyleSheetType</baseType>
      <methodName>getBytesLoaded</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_StyleSheet_getBytesTotal">
      <baseType>kStyleSheetType</baseType>
      <methodName>getBytesTotal</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_IME_addListener">
      <baseType>kIMEType</baseType>
      <methodName>addListener</methodName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_IME_removeListener">
      <baseType>kIMEType</baseType>
      <methodName>removeListener</methodName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_IME_getEnabled">
      <baseType>kIMEType</baseType>
      <methodName>getEnabled</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_IME_setEnabled">
      <baseType>kIMEType</baseType>
      <methodName>setEnabled</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_IME_getInstance">
      <baseType>kIMEType</baseType>
      <methodName>getInstance</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_IME_getConversionMode">
      <baseType>kIMEType</baseType>
      <methodName>getConversionMode</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_IME_setConversionMode">
      <baseType>kIMEType</baseType>
      <methodName>setConversionMode</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_TextField_getNewTextFormat">
      <baseType>kTextFieldType</baseType>
      <methodName>getNewTextFormat</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_TextField_setNewTextFormat">
      <baseType>kTextFieldType</baseType>
      <methodName>setNewTextFormat</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_TextField_getDepth">
      <baseType>kTextFieldType</baseType>
      <methodName>getDepth</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_TextField_swapDepths">
      <baseType>kTextFieldType</baseType>
      <methodName>swapDepths</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_TextField_getInstanceAtDepth">
      <baseType>kTextFieldType</baseType>
      <methodName>getInstanceAtDepth</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_TextField_getNextHighestDepth">
      <baseType>kTextFieldType</baseType>
      <methodName>getNextHighestDepth</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_TextField_replaceSel">
      <baseType>kTextFieldType</baseType>
      <methodName>replaceSel</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_TextField_getLineIndexOfCharacter">
      <baseType>kTextFieldType</baseType>
      <methodName>getLineIndexOfCharacter</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_TextField_getSelectionBeginIndex">
      <baseType>kTextFieldType</baseType>
      <methodName>getSelectionBeginIndex</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_TextField_getSelectionEndIndex">
      <baseType>kTextFieldType</baseType>
      <methodName>getSelectionEndIndex</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_TextField_getCaretIndex">
      <baseType>kTextFieldType</baseType>
      <methodName>getCaretIndex</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_TextField_getFontList">
      <baseType>kTextFieldType</baseType>
      <methodName>getFontList</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_TextSnapshot_getCount">
      <baseType>kTextSnapshotType</baseType>
      <methodName>getCount</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_URLLoader_send">
      <baseType>kURLLoaderType</baseType>
      <methodName>send</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_URLStream_available">
      <baseType>kURLStreamType</baseType>
      <methodName>available</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_URLRequest_addRequestHeader">
      <baseType>kURLRequestType</baseType>
      <methodName>addRequestHeader</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_XMLDocument_load">
      <baseType>kXMLDocumentType</baseType>
      <methodName>load</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_XMLDocument_send">
      <baseType>kXMLDocumentType</baseType>
      <methodName>send</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_XMLDocument_sendAndLoad">
      <baseType>kXMLDocumentType</baseType>
      <methodName>sendAndLoad</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_XMLDocument_onData">
      <baseType>kXMLDocumentType</baseType>
      <methodName>onData</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_XMLDocument_addRequestHeader">
      <baseType>kXMLDocumentType</baseType>
      <methodName>addRequestHeader</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_XMLDocument_getBytesLoaded">
      <baseType>kXMLDocumentType</baseType>
      <methodName>getBytesLoaded</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_XMLDocument_getBytesTotal">
      <baseType>kXMLDocumentType</baseType>
      <methodName>getBytesTotal</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    
    <unsupported label="kUnsupportedMeth_Button">
      <baseType>kVoidType</baseType>
      <methodName>Button</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Container">
      <baseType>kVoidType</baseType>
      <methodName>Container</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Image">
      <baseType>kVoidType</baseType>
      <methodName>Image</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_ImageFilter">
      <baseType>kVoidType</baseType>
      <methodName>ImageFilter</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_ImageSprite">
      <baseType>kVoidType</baseType>
      <methodName>ImageSprite</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_ImageLoaderInfo">
      <baseType>kVoidType</baseType>
      <methodName>ImageLoaderInfo</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_ImeEvent">
      <baseType>kVoidType</baseType>
      <methodName>ImeEvent</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_Key">
      <baseType>kVoidType</baseType>
      <methodName>Key</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_LineMetrics">
      <baseType>kVoidType</baseType>
      <methodName>LineMetrics</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_LoadVars">
      <baseType>kVoidType</baseType>
      <methodName>LoadVars</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MenuEvent">
      <baseType>kVoidType</baseType>
      <methodName>MenuEvent</methodName>
      <isStatic>false</isStatic>
    </unsupported>
     <unsupported label="kUnsupportedMeth_MovieClipLoader">
      <baseType>kVoidType</baseType>
      <methodName>MovieClipLoader</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_SystemCapabilities">
      <baseType>kVoidType</baseType>
      <methodName>SystemCapabilities</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_SystemCapabilities">
      <baseType>kVoidType</baseType>
      <methodName>SystemCapabilities</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_TextExtents">
      <baseType>kVoidType</baseType>
      <methodName>TextExtents</methodName>
      <isStatic>false</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_System_showSettings">
      <baseType>kSystemType</baseType>
      <methodName>showSettings</methodName>
      <isStatic>true</isStatic>
    </unsupported>    
    <unsupported label="kUnsupportedMeth_BitmapData_loadBitmap">
      <baseType>kBitmapDataType</baseType>
      <methodName>loadBitmap</methodName>
      <isStatic>true</isStatic>
    </unsupported>
    <unsupported label="kUnsupportedMeth_MovieClip_loadVariables">
      <baseType>kMovieClipType</baseType>
      <methodName>loadVariables</methodName>
      <isStatic>false</isStatic>
    </unsupported>
	<unsupported label="kUnsupportedMeth_FileReferenceList_addListener">
		<baseType>kFileReferenceListType</baseType>
		<methodName>addListener</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_FileReferenceList_removeListener">
		<baseType>kFileReferenceListType</baseType>
		<methodName>removeListener</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Date_getYear">
		<baseType>kDateType</baseType>
		<methodName>getYear</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Date_setYear">
		<baseType>kDateType</baseType>
		<methodName>setYear</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Date_getUTCYear">
		<baseType>kDateType</baseType>
		<methodName>getUTCYear</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<!-- unsupported label="kUnsupportedMeth_BitmapFilter_clone">
		<baseType>kBitmapFilterType</baseType>
		<methodName>clone</methodName>
		<isStatic>false</isStatic>
	</unsupported-->
	<unsupported label="kUnsupportedMeth_Microphone_setGain">
		<baseType>kMicrophoneType</baseType>
		<methodName>setGain</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Microphone_setRate">
		<baseType>kMicrophoneType</baseType>
		<methodName>setRate</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Selection">
		<baseType>kVoidType</baseType>
		<methodName>Selection</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_ColorTransform_getTransform">
		<baseType>kColorTransformType</baseType>
		<methodName>getTransform</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_ColorTransform_setTransform">
		<baseType>kColorTransformType</baseType>
		<methodName>setTransform</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Sound_loadSound">
		<baseType>kSoundType</baseType>
		<methodName>loadSound</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Sound_getVolume">
		<baseType>kSoundType</baseType>
		<methodName>getVolume</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Sound_getTransform">
		<baseType>kSoundType</baseType>
		<methodName>getTransform</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Sound_getPan">
		<baseType>kSoundType</baseType>
		<methodName>getPan</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Sound_setPan">
		<baseType>kSoundType</baseType>
		<methodName>setPan</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_MovieClip_beginBitmapFill">
		<baseType>kDisplayObjectType</baseType>
		<methodName>beginBitmapFill</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_MovieClip_hitTest">
		<baseType>kDisplayObjectType</baseType>
		<methodName>hitTest</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_MovieClip_attachBitmap">
		<baseType>kDisplayObjectType</baseType>
		<methodName>attachBitmap</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_call">
		<baseType>kVoidType</baseType>
		<methodName>call</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Color">
		<baseType>kVoidType</baseType>
		<methodName>Color</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_capabilities">
		<baseType>kVoidType</baseType>
		<methodName>capabilities</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Sound_getBytesLoaded">
		<baseType>kSoundType</baseType>
		<methodName>getBytesLoaded</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_Sound_getBytesTotal">
		<baseType>kSoundType</baseType>
		<methodName>getBytesTotal</methodName>
		<isStatic>false</isStatic>
	</unsupported>
    <unsupported label="kUnsupportedMeth_TextFormat_getTextExtent">
		<baseType>kTextFormatType</baseType>
		<methodName>getTextExtent</methodName>
		<isStatic>false</isStatic>
    </unsupported>
	<unsupported label="kUnsupportedMeth_FileReference_addListener">
		<baseType>kFileReferenceType</baseType>
		<methodName>addListener</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_FileReference_removeListener">
		<baseType>kFileReferenceType</baseType>
		<methodName>removeListener</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_eval">
		<baseType>kVoidType</baseType>
		<methodName>eval</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_getVersion">
		<baseType>kVoidType</baseType>
		<methodName>getVersion</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kUnsupportedMeth_ifFrameLoaded">
		<baseType>kVoidType</baseType>
		<methodName>ifFrameLoaded</methodName>
		<isStatic>false</isStatic>
	</unsupported>	
</methods>

<events>
	<unsupported label="kWarning_Event_onStatus">
		<baseType>kSystemType</baseType>
		<methodName>onStatus</methodName>
		<isStatic>true</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onID3">
		<baseType>kSoundType</baseType>
		<methodName>onID3</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onLoad">
		<baseType>kSoundType</baseType>
		<methodName>onLoad</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onSoundComplete">
		<baseType>kSoundType</baseType>
		<methodName>onSoundComplete</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onResize">
		<baseType>kStageType</baseType>
		<methodName>onResize</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onChanged">
		<baseType>kTextFieldType</baseType>
		<methodName>onChanged</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onKillFocus">
		<baseType>kTextFieldType</baseType>
		<methodName>onKillFocus</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onScroller">
		<baseType>kTextFieldType</baseType>
		<methodName>onScroller</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onSetFocus">
		<baseType>kTextFieldType</baseType>
		<methodName>onSetFocus</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onLoad">
		<baseType>kStyleSheetType</baseType>
		<methodName>onLoad</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onMouseDown">
		<baseType>kMouseType</baseType>
		<methodName>onMouseDown</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onMouseUp">
		<baseType>kMouseType</baseType>
		<methodName>onMouseUp</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onMouseMove">
		<baseType>kMouseType</baseType>
		<methodName>onMouseMove</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onMouseWheel">
		<baseType>kMouseType</baseType>
		<methodName>onMouseWheel</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onKeyDown">
		<baseType>kKeyboardType</baseType>
		<methodName>onKeyDown</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onKeyUp">
		<baseType>kKeyboardType</baseType>
		<methodName>onKeyUp</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onData">
		<baseType>kLoaderType</baseType>
		<methodName>onData</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onLoad">
		<baseType>kLoaderType</baseType>
		<methodName>onLoad</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onDragOut">
		<baseType>kSimpleButtonType</baseType>
		<methodName>onDragOut</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onDragOver">
		<baseType>kSimpleButtonType</baseType>
		<methodName>onDragOver</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onKeyDown">
		<baseType>kSimpleButtonType</baseType>
		<methodName>onKeyDown</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onKeyUp">
		<baseType>kSimpleButtonType</baseType>
		<methodName>onKeyUp</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onKillFocus">
		<baseType>kSimpleButtonType</baseType>
		<methodName>onKillFocus</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onPress">
		<baseType>kSimpleButtonType</baseType>
		<methodName>onPress</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onRelease">
		<baseType>kSimpleButtonType</baseType>
		<methodName>onRelease</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onReleaseOutside">
		<baseType>kSimpleButtonType</baseType>
		<methodName>onReleaseOutside</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onRollOut">
		<baseType>kSimpleButtonType</baseType>
		<methodName>onRollOut</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onRollOver">
		<baseType>kSimpleButtonType</baseType>
		<methodName>onRollOver</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onSetFocus">
		<baseType>kSimpleButtonType</baseType>
		<methodName>onSetFocus</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onActivity">
		<baseType>kCameraType</baseType>
		<methodName>onActivity</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onStatus">
		<baseType>kCameraType</baseType>
		<methodName>onStatus</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onSelect">
		<baseType>kContextMenuType</baseType>
		<methodName>onSelect</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onSelect">
		<baseType>kContextMenuItemType</baseType>
		<methodName>onSelect</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onActivity">
		<baseType>kMicrophoneType</baseType>
		<methodName>onActivity</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onStatus">
		<baseType>kMicrophoneType</baseType>
		<methodName>onStatus</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onData">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onData</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onDragOut">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onDragOut</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onDragOver">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onDragOver</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onEnterFrame">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onEnterFrame</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onKeyDown">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onKeyDown</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onKeyUp">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onKeyUp</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onKillFocus">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onKillFocus</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onLoad">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onLoad</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onMouseDown">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onMouseDown</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onMouseMove">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onMouseMove</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onMouseUp">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onMouseUp</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onPress">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onPress</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onRelease">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onRelease</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onReleaseOutside">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onReleaseOutside</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onRollOut">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onRollOut</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onRollOver">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onRollOver</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onSetFocus">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onSetFocus</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onUnload">
		<baseType>kDisplayObjectType</baseType>
		<methodName>onUnload</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onLoadComplete">
		<baseType>kLoaderType</baseType>
		<methodName>onLoadComplete</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onLoadError">
		<baseType>kLoaderType</baseType>
		<methodName>onLoadError</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onLoadInit">
		<baseType>kLoaderType</baseType>
		<methodName>onLoadInit</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onLoadProgress">
		<baseType>kLoaderType</baseType>
		<methodName>onLoadProgress</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onLoadStart">
		<baseType>kLoaderType</baseType>
		<methodName>onLoadStart</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onStatus">
		<baseType>kNetStreamType</baseType>
		<methodName>onStatus</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onData">
		<baseType>kXMLType</baseType>
		<methodName>onData</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onLoad">
		<baseType>kXMLType</baseType>
		<methodName>onLoad</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onClose">
		<baseType>kXMLSocketType</baseType>
		<methodName>onClose</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onConnect">
		<baseType>kXMLSocketType</baseType>
		<methodName>onConnect</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onData">
		<baseType>kXMLSocketType</baseType>
		<methodName>onData</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onXML">
		<baseType>kXMLSocketType</baseType>
		<methodName>onXML</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onSelect">
		<baseType>kFileReferenceListType</baseType>
		<methodName>onSelect</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onCancel">
		<baseType>kFileReferenceListType</baseType>
		<methodName>onCancel</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onData">
		<baseType>kXMLDocumentType</baseType>
		<methodName>onData</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onHTTPStatus">
		<baseType>kXMLDocumentType</baseType>
		<methodName>onHTTPStatus</methodName>
		<isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onLoad">
		<baseType>kXMLDocumentType</baseType>
		<methodName>onLoad</methodName>
		<isStatic>false</isStatic>
	</unsupported>
    <unsupported label="kWarning_Event_onStatus">
      <baseType>kSharedObjectType</baseType>
      <methodName>onStatus</methodName>
      <isStatic>false</isStatic>
    </unsupported>
	<unsupported label="kWarning_Event_onStatus">
	  <baseType>kLocalConnectionType</baseType>
	  <methodName>onStatus</methodName>
	  <isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onIMEComposition">
	  <baseType>kIMEType</baseType>
	  <methodName>onIMEComposition</methodName>
	  <isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onCancel">
	  <baseType>kFileReferenceType</baseType>
	  <methodName>onCancel</methodName>
	  <isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onComplete">
	  <baseType>kFileReferenceType</baseType>
	  <methodName>onComplete</methodName>
	  <isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onHTTPError">
	  <baseType>kFileReferenceType</baseType>
	  <methodName>onHTTPError</methodName>
	  <isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onIOError">
	  <baseType>kFileReferenceType</baseType>
	  <methodName>onIOError</methodName>
	  <isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onOpen">
	  <baseType>kFileReferenceType</baseType>
	  <methodName>onOpen</methodName>
	  <isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onProgress">
	  <baseType>kFileReferenceType</baseType>
	  <methodName>onProgress</methodName>
	  <isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onSecurityError">
	  <baseType>kFileReferenceType</baseType>
	  <methodName>onSecurityError</methodName>
	  <isStatic>false</isStatic>
	</unsupported>
	<unsupported label="kWarning_Event_onSelect">
	  <baseType>kFileReferenceType</baseType>
	  <methodName>onSelect</methodName>
	  <isStatic>false</isStatic>
	</unsupported>
</events>

</AS2LintWarnings>
