# assoc_text

text:
= {"★OPEN YOUR EYES","02 罪の子らの賛美歌","03 大陸遠望","04 勝利！","05 予期せぬ終結","06 つかの間の休息","07 眠れない夜は","08 ENCOUNTER BATTLE","09 戦闘＃2","10 聖堂","11 フィールド＃1","12 舞踏会","13 トランクォーリー","14 緊迫","15 ラグニ村","16 出発の日","17 大海原へ","18 港町タイニ","19 悪だくみ","20 さぁ、特訓だ！","21 闇の足音　－予兆－","22 国境都市マルテュニ","23 共和国首都ドーム","24 差し迫る危機","25 急げ！","26 ふたりで…","27 フィールド＃2","28 いつもの朝","29 港町アンスヴェルス","30 サルディス湾","31 聖都バアラ","32 エリザベス・エンジン","33 なつかしい景色","34 ダンジョン＃1","35 オカリナ","36 EVERLASTING NIGHTMARE","37 ラグニ村　another version","38 BURST INTO THE BATTLE","39 フィールド＃3","40 荒廃の影","41 分かたれた道","42 神との決別","43 対決","44 フィールド＃4","45 プリセロナのテーマ","46 DESTRUCTION","47 エステニュ・チョダル","48 不吉","49 セテバン研究地区","50 DESERTED TOWN","51 祈り","52 変わりゆく世界","53 ラクリモサ渓谷","54 ESPIONAGE","55 エルハイヴ要塞","56 降臨","57 戦闘＃4","58 フィールド＃5","59 ゲルナ高原","60 幻夢","61 BREAKTHROUGH","62 エペソ","63 あるマギの記憶","64 審判の時","65 MBRACE","66 戦闘＃5","67 FINAL ASSAULT","68 フィールド＃5","69 凍てついた過去","70 FALL OF THE EMPIRE","71 コンステルラリウム","72 N.O.A.H.","73 EDEN","74 旅の想い出","75 鎮魂歌","76 迫りくる脅威","77 CASTLE WALKENSWAARD","78 礼拝堂　～アケナトン～","79 ダンジョン＃2","80 ダンジョン＃3","81 エピローグ","82 Truth In Me","84 幻夢"}


text:
= {"VT01DA Brandish4 -OP-","VT03DA 古の祈り-meditation-","VT05DA 遺跡-the prop-","VT13DA ショップ-relation-","VT32DA 迷宮-roar-","VT04DA 街区-division-","VT14DA カジノ-eighth wonder-","VT19DA 遊戯-hammer slime-","VT15DA 闘場-black field-","VT16DA 塔の謎-mysterious-","VT27DA 遺跡2-debris-","VT18DA 死闘-trigger-","VT28DA 遺跡3-deep haze-","VT06DA 水域-the abyss-","VT07DA 庭園-bramble-","VT33DA 召喚-hostile-","VT08DA 城塞-solid steel-","VT09DA 聖堂-judgement-","VT17DA 塔の復活-retribution-","VT10DA 胎内-forbidden power-","VT30DA 決闘-fatal riders-","VT11DA 神殿-heritage-","VT12DA 忘却の迷宮-another door-","VT34DA 祭壇-altar-","VT20DA ギリアス-victim-","VT39DA エピローグI-daybreak-","VT40DA エピローグII-twilght-","VT41DA エピローグIV-broken chain-","VT21DA VT21(エンディング用)","VT22DA VT22(エンディング用)","VT35DA ENDING","VT02DA Staff","VT36DA 休息-slumber-","VT31DA GAME OVER","VT38DA イントロダクション","VT43DA ジングル：詩人1","VT44DA ジングル：詩人2","VT45DA ジングル：詩人3","VT46DA ジングル：詩人4","VT47DA ジングル：詩人5","VT48DA ジングル：詩人6","VT49DA ジングル：詩人7"}


text:
bool operator ==( const Int24& a, NUM b) { return a.getval() == b; } bool operator !=( const Int24& a, NUM b) { return a.getval() != b; } bool operator >=( const Int24& a, NUM b) { return a.getval() >= b; } bool operator <=( const Int24& a, NUM b) { return a.getval() <= b; } bool operator > ( const Int24& a, NUM b) { return a.getval() > b; } bool operator < ( const Int24& a, NUM b) { return a.getval() < b; } bool operator ==( NUM b, const Int24& a) { return b == a.getval(); } bool operator !=( NUM b, const Int24& a) { return b != a.getval(); } bool operator >=( NUM b, const Int24& a) { return b >= a.getval(); } bool operator <=( NUM b, const Int24& a) { return b <= a.getval(); } bool operator > ( NUM b, const Int24& a) { return b > a.getval(); } bool operator < ( NUM b, const Int24& a) { return b < a.getval(); }


text:
NUM operator +( const Int24& val, NUM b ) {return val.getval() + b;} NUM operator -( const Int24& val, NUM b ) {return val.getval() - b;} NUM operator *( const Int24& val, NUM b ) {return val.getval() * b;} NUM operator /( const Int24& val, NUM b ) {return val.getval() / b;} NUM operator +( NUM b, const Int24& val ) {return b + val.getval();} NUM operator -( NUM b, const Int24& val ) {return b - val.getval();} NUM operator *( NUM b, const Int24& val ) {return b * val.getval();} NUM operator /( NUM b, const Int24& val ) {return b / val.getval();}


text:
NUM operator %( const Int24& val, NUM b ) {return val.getval() % b;} Int24 operator >>( const Int24& val, NUM b ) {return Int24( val.getval() >> b );} Int24 operator <<( const Int24& val, NUM b ) {return Int24( val.getval() << b );} NUM operator %( NUM b, const Int24& val ) {return b % val.getval();} NUM operator >>( NUM b, const Int24& val ) {return b >> val.getval();} NUM operator <<( NUM b, const Int24& val ) {return b << val.getval();}


text:
= {kALACChannelLayoutTag_Mono,kALACChannelLayoutTag_Stereo,kALACChannelLayoutTag_MPEG_3_0_B,kALACChannelLayoutTag_MPEG_4_0_B,kALACChannelLayoutTag_MPEG_5_0_D,kALACChannelLayoutTag_MPEG_5_1_D,kALACChannelLayoutTag_AAC_6_1,kALACChannelLayoutTag_MPEG_7_1_B}


text:
"audio/mpeg {stdmpg ffmpeg} audio/x-mpeg {stdmpg ffmpeg} application/ogg {stdogg opus ffmpeg} audio/ogg {stdogg opus ffmpeg} audio/aac {aac ffmpeg} audio/aacp {aac ffmpeg} audio/x-m4a {aac ffmpeg} audio/wma {wma ffmpeg}"


text:
((((int64_t)x << 56) | (((int64_t)x << 40) & 0x00ff000000000000LL) | (((int64_t)x << 24) & 0x0000ff0000000000LL) | (((int64_t)x << 8) & 0x000000ff00000000LL) | (((int64_t)x >> 8) & 0x00000000ff000000LL) | (((int64_t)x >> 24) & 0x0000000000ff0000LL) | (((int64_t)x >> 40) & 0x000000000000ff00LL) | (((int64_t)x >> 56) & 0x00000000000000ffLL)))


text:
_mm_unpacklo_epi32(_mm_shuffle_epi32(_mm_mul_epu32(a, b), 0xd8), _mm_shuffle_epi32(_mm_mul_epu32(_mm_shuffle_epi32(a, 0xb1), _mm_shuffle_epi32(b, 0xb1)), 0xd8))


text:
= {"Blues","Classic Rock","Country","Dance","Disco","Funk","Grunge","Hip-Hop","Jazz","Metal","New Age","Oldies","Other","Pop","R&B","Rap","Reggae","Rock","Techno","Industrial","Alternative","Ska","Death Metal","Pranks","Soundtrack","Euro-Techno","Ambient","Trip-Hop","Vocal","Jazz+Funk","Fusion","Trance","Classical","Instrumental","Acid","House","Game","Sound Clip","Gospel","Noise","AlternRock","Bass","Soul","Punk","Space","Meditative","Instrumental Pop","Instrumental Rock","Ethnic","Gothic","Darkwave","Techno-Industrial","Electronic","Pop-Folk","Eurodance","Dream","Southern Rock","Comedy","Cult","Gangsta","Top 40","Christian Rap","Pop/Funk","Jungle","Native American","Cabaret","New Wave","Psychadelic","Rave","Showtunes","Trailer","Lo-Fi","Tribal","Acid Punk","Acid Jazz","Polka","Retro","Musical","Rock & Roll","Hard Rock","Folk","Folk/Rock","National Folk","Swing","Fast-Fusion","Bebob","Latin","Revival","Celtic","Bluegrass","Avantgarde","Gothic Rock","Progressive Rock","Psychedelic Rock","Symphonic Rock","Slow Rock","Big Band","Chorus","Easy Listening","Acoustic","Humour","Speech","Chanson","Opera","Chamber Music","Sonata","Symphony","Booty Bass","Primus","Porn Groove","Satire","Slow Jam","Club","Tango","Samba","Folklore","Ballad","Power Ballad","Rhythmic Soul","Freestyle","Duet","Punk Rock","Drum Solo","A capella","Euro-House","Dance Hall","Goa","Drum & Bass","Club House","Hardcore","Terror","Indie","BritPop","NegerPunk","Polsk Punk","Beat","Christian Gangsta","Heavy Metal","Black Metal","Crossover","Contemporary C","Christian Rock","Merengue","Salsa","Thrash Metal","Anime","JPop","SynthPop",}


text:
= {{"\xA9" "nam","title"},{"\xA9" "ART","artist"},{"\xA9" "wrt","writer"},{"\xA9" "alb","album"},{"\xA9" "day","date"},{"\xA9" "too","tool"},{"\xA9" "cmt","comment"},{"cpil","compilation"},{"covr","cover"},{"aART","album_artist"},}


text:
= {"dinow_01 失われしものたち","dinow_02 Mark My Words","dinow_03 精霊の賛歌","dinow_04 FRONT LINE","dinow_05 突破！","dinow_06 A TEMPLE","dinow_07 GOD！","dinow_08 土笛","dinow_09 EXCITING SHOP","dinow_10 INTO THE CASTLE","dinow_11 タルシスとの出会い","dinow_12 戦いは悲しみの果てに","dinow_13 邂逅の時","dinow_14 BURNING!","dinow_15 鎮魂","dinow_16 神の啓示","dinow_17 試練の塔","dinow_18 龍が逝く時","dinow_19 風の塔","dinow_20 地下祭室","dinow_21 次元の迷宮","dinow_22 ダリウスの塔","dinow_23 あなたを愛して","dinow_24 竪琴","dinow_25 汚れなき時","dinow_26 THE MASCLE MAN","dinow_27 フォルナ","dinow_28 精霊の塔","dinow_29 軍神","dinow_30 DINOSAUR","dinow_31 夢つむぎ","dinow_32 風の紋章","dinow_33 オルゴール","★オープニング"}


text:
= {{22.0138095238095,181.765351473923},{9.08820861678005,86.2321315192744},{10.3009070294785,168.109569160998},{9.56086167800454,68.3846258503401},{8.93421768707483,156.790839002268},{10.2299546485261,178.878843537415},{33.8431065759637,144.95537414966},{0.0,0.0},{7.16244897959183,130.49537414966},{9.3097052154195,113.093537414966},{11.7062131519274,129.33},{7.65356009070295,83.9453741496598},{8.9562358276644,97.219433106576},{4.27621315192744,138.798526077098},{0.0,0.0},{4.63199546485261,108.084285714286},{21.455283446712,168.808344671202},{45.0247392290249,102.797800453515},{3.32027210884354,242.057142857143},{14.3692743764172,80.6851473922902},{15.9714965986395,71.0846031746031},{16.7838548752834,87.2922902494331},{25.8584126984127,151.348548752834},{0.0,0.0},{22.0648526077098,88.363514739229},{17.430589569161,120.630589569161},{22.9173469387755,136.020158730159},{6.70092970521542,129.01514739229},{18.1054195011338,51.105306122449},{21.3657596371882,113.737709750567},{13.3610657596372,206.219138321996},{82.3797732426304,161.312947845805},{0.0,0.0},{0.0,0.0}}


text:
= {"ED3940DA 白き魔女ゲルド","ED3940DA もうひとつの英雄たちの物語","ED3200DA 愛はきらめきのなかに","ED3201DA 小さな英雄 -オルゴール-","ED3104DA 俺様ライオン､おまえを喰らうぞ-Original-","ED3106DA WIN!! -Original-","ED3111DA シャーラ＆グース","ED3101DA MOUNTAIN PATH","ED3112DA FEEL SO GOOD","ED3110DA 関所","ED3103DA 洞窟","ED3119DA シャリネ","ED3102DA 浜辺の午後","ED3107DA しあわせな一日","ED3203DA 気分はキャプテン･トーマス","ED3120DA 犯人は誰だ?!","ED3113DA 愉快な仲間たち","ED3108DA 風といっしょに","ED3121DA 小さな英雄 -ジュリオとクリスの大冒険-","ED3100DA LET'S START, OK?","ED3302DA 炭坑","ED3300DA ガルガのつめ痕","ED3116DA ローディ","ED3403DA GAMBLER","ED3400DA 毒沼","ED3117DA 白き魔女ゲルド -軌跡-","ED3402DA ダーツ","ED3115DA 哀しみのメロディ","ED3401DA それ見よ我が元気","ED3405DA 嵐の前","ED3404DA ボルト大決戦","ED3105DA 強敵!!","ED3118DA あ､負けちゃった","ED3000DA 不思議なお話を","ED3501DA 俺様ライオン､おまえを喰らうぞ-Arrange-","ED3502DA WIN!! -Arrange-","ED3109DA 円舞曲","ED3700DA 男ひとり旅","ED3506DA フラダンシング･オールナイト","ED3500DA 迷いの森 -Original-","ED3601DA 迷いの森 -Arrange-","ED3604DA オルドス","ED3600DA オルドス大聖堂","ED3602DA まろうどの賛歌","ED3603DA ラウアール","ED3800DA ギドナ","ED3801DA 赤い瞳の誘惑","ED3803DA バダット","ED3802DA ガガーブの記憶","ED3114DA 夢","ED3900DA INVASION","ED3504DA ゲルドへの路","ED3902DA 回想 -レクイエム-","ED3920DA ルード城","ED3923DA 魔獣出現","ED3924DA 天儀室","ED3503DA 王妃イザベル 戦闘前","ED3921DA 王妃イザベル 戦闘","ED3925DA 白き魔女ゲルド -尊き魂-","ED3926DA 小さな英雄 -青空のむこうに-","ED3927DA 終焉","ED3928DA デュルゼルの手紙","ED3505DA ラグピック村エンディングVer.","ED3507DA Leone Fredrik Richter","ED3930DA HEROES2","ED3931DA 小さな英雄 -冬の到来-","ED3932DA ティラスイールの白き魔女"}


text:
= {"E4S00 朱紅い雫　-memoria-","★OP1 朱紅い雫　-伝承-（オープニングムービー）","★OP2 絆　-熱き想いを胸に（オープニングムービー）","E4B01 ぬくもりに抱かれて・・・","E4N28 異端者の襲撃　-邪神オクトゥムの陰-","E4A00 やすらぎの日々","E4S02 いつか来た村","E4S04 足取り軽く","E4N00 そりゃあないでSHOW","E4S05 希望へ続く道","E4S13 負けるものか！","E4A01 王都フィルディン","E4A02 フィルディン城","E4N01 さらに愉快な仲間たち","E4S17 走れアヴィン！！","E4C01 怯える人々","E4N17 向かうべき路途（みち）へ","E4S06 暗闇に巣食う者","E4S14 迷宮乱舞","E4S28 シャムシール団","E4S18 元気なシャノン","E4S07 森を行け","E4N24 朱紅い雫 -神に選ばれし娘-","E4S01 にぎやかな街角","E4C00 鉄鋼の町～ギア～","E4S15 邪魔をするな！","E4S24 明日があります","E4C03 途方にくれて -ギア・ブルース-","E4S03 潮風のリズム","E4S11 海原を風に乗り","E4S25 朱紅い雫　-愛しのアイメル-","E4N14 朱紅い雫 -幸せな時間（とき）-","E4N20 燃えろアヴィン！！","E4N25 たすけに来たぜ！","E4N19 朱紅い雫 -待ってろアイメル-","E4N99 楽勝！","E4N22 旅立ち","E4N12 邪神官ベリアス -襲撃-","E4E00 聖都","E4E01 礼拝堂 -運命と宿命の中で-","E4N10 絆 -哀しみを越えて-","E4N11 Blue -取り戻す旅-","E4N29 守るべき一線","E4D00 真実を求めて","E4N80 我が名はバルドゥス　-真実-","E4N15 バルドゥスの眠りし祠","E4N33 死闘　-汚された精霊-","E4N23 暗雲たちこめる中で","E4S10 太古の遺産","E4S08 泥炭沼","E4N13 神々の犠牲","E4N27 異端者の襲撃　-ボルゲイド-","E4S19 絆　-凍てつくほどに-","E4N81 我が名はバルドゥス　-集結-","E4G06 我が名はバルドゥス -集結-","E4N32 避けられぬ戦い","E4G00 封印の地","E4G02 時空間迷宮","E4G03 邪神官ベリアス -信念-","E4G04 我が信念の為に！","E4G05 オクトゥムの願い","E4N30 かくも強き願い　-代償-","E4N34 かくも強き願い　-冥府-","E4N31 ルティスのこころ","E4N26 絆 -それぞれの場所へ-","E4N35 朱紅い雫　-エンドクレジット-"}


text:
= {"ED5WV002 Leone Fredrik Richter \"海の檻歌\"","ED5WV065 寝坊のタッド(フォルト)","ED5WV020 やすらぎの時","ED5WV030 陽のあたる丘で","ED5WV006 春のうた(マクべイン)","ED5WV068 風のセレナーデ(アルトス)","ED5WV036 そよ風の唄","ED5WV041 闇に宿る静寂","ED5WV012 魔獣が出てきてさぁ大変!","ED5WV011 楽勝!...かな?","ED5WV024 潮風に誘われて","ED5WV081 闇よりの使者","ED5WV015 なんだこの野郎!","ED5WV033 潮風に包まれて","ED5WV052 シャオとレイチェル","ED5WV053 およびでないでSHOW","ED5WV031 青空へ登る道","ED5WV034 Deep Forest","ED5WV023 恋する季節","ED5WV061 レオーネのエチュード(シュベール)","ED5WV107 レオーネのエチュード(マクベイン一座)","ED5WV084 お宝いただき!","ED5WV013 あとには引けない","ED5WV089 哀しみを越えて","ED5WV025 ルプシャ隊行進曲","ED5WV022 Harvest","ED5WV055 皇帝の休日(バルダザール)","ED5WV056 野いちご摘み(ウェンディ)","ED5WV079 砂漠の舞い(アーガス＆カチュア)","ED5WV067 ピエロの行進(シャオ＆レイチェル)","ED5WV108 森と海のメモリア(マクベイン一座)","ED5WV058 ルーレットまかせ","ED5WV050 涙はあの日の想いとともに","ED5WV057 絶体絶命!","ED5WV016 力の限り","ED5WV010 さよなら・・","ED5WV037 焦燥","ED5WV059 水底の子守歌(アリア)","ED5WV080 黒き皇国","ED5WV086 守るべきもののために","ED5WV076 いざないの歌(アリア)","ED5WV077 いざないの歌(フォルト)","ED5WV021 永遠なる民の町","ED5WV083 レオーネの軌跡","ED5WV035 Hot and Cool","ED5WV045 波紋","ED5WV044 使命に燃えて","ED5WV038 ヌメロスの影","ED5WV090 闇の太陽｢復活｣","ED5WV093 狂気の代償","ED5WV042 漆黒の空","ED5WV073 水底のメロディー｢隠者｣(ウーナ)","ED5WV088 水底のメロディー｢異界へ｣","ED5WV048 明日を生きるために","ED5WV085 たすけに来たぜ!","ED5WV032 その闇の向こうに","ED5WV019 邪魔する者は容赦しない","ED5WV026 Leone Fredrik Richter \"もうひとつの世界\"","ED5WV071 水底のメロディー｢誕生｣(ウーナ)","ED5WV008 水底のメロディー｢浮上｣(マクベイン一座＆アリア)","ED5WV070 青き葬送(デュオール)","ED5WV047 闇の太陽｢遺跡｣","ED5WV017 行く手を遮る者","ED5WV018 それぞれの未来に","ED5WV007 水底の子守歌(フォルト)","ED5WV110 海の檻歌･組曲プロローグ｢封印解除｣","ED5WV111 海の檻歌･組曲セグエ｢水底のメロディー｣","ED5WV112 海の檻歌･組曲アリア｢水底の子守歌｣","ED5WV113 海の檻歌･組曲フィナーレ｢Leone Fredrik Richter｣","ED5WV116 愛を感じていたい｢終焉｣","ED5WV069 水底のメロディー｢誕生｣(フォルト)","ED5WV118 それぞれの明日へ～Leone Fredrik Richter \"End Credits\"","ED5WV119 愛を感じていたい「そして・・」","ED5WV001 Leone FredrikRichter \"Theme\"","ED5WV100 それ見よ我が元気(フォルト)","ED5WV101 木漏れ日の詩(マクベイン)","ED5WV102 ゆかいな小鳥(ウーナ)","ED5WV103 旅人たちの前奏曲(マクベイン一座)","ED5WV104 陽気な旅人(マクベイン一座)","ED5WV105 ともに踊らん(マクベイン一座)","ED5WV106 心を開いて(マクベイン一座)","ED5WV062 星屑のカンタータ(+ヴァイオリン)","ED5WV074 水底のメロディー「心眼」(フォルト)","ED5WV096 水底のメロディー「愛」(フォルト)","ED5WV095 水底のメロディー「生命」(マクベイン)","ED5WV066 ピエロの行進･下手版(シャオ＆レイチェル)","ED5WV097 ダンジョン３","ED5WV078 レオーネの口笛","ED5WV003 ファルコムのロゴ","ED5WV060 星屑のカンタータ(ラスト)","ED5WV063 星屑のカンタータ（会場外VER）","ED5WV064 星屑のカンタータ(ヴァイオリン1)","ED5WV087 星屑のカンタータ(ヴァイオリン2)","ED5WV092 それ見よ我が元気･街頭演奏版(フォルト)","ED5WV094 青き葬送(デュオール)","ED5WV098 ともに踊らん(マクベイン一座)","ED5WV099 心を開いて(マクベイン一座＆シャオ･レイチェル)","ED5WV109 ともに踊らん(マクベイン一座)"}


text:
= {"001◆風を共に舞う気持ち SC Ver","020◆仄かに煌く光","021◆Cry for me, cry for you Opening version","022◆空を見上げて Ending version","024◆荒野にそびえし威容","100　地方都市ロレント","101　商業都市ボース","102　海港都市ルーアン","103　工房都市ツァイス","104　王都グランセル","105　陽だまりにて和む猫","106　国境警備も楽じゃない","107　王城","108　グランアリーナ","110　ル＝ロックルへようこそ","111　灯火が消えた街","112　Heartless Surprise Attack","113　飛行戦艦グロリアス","120◆隠者の庭園","121◆紫苑の家","122◆御心のままに","123◆最後の選択","200　リベールの歩き方","201　Secret Green Passage","202　Rock on the Road","210　空を見上げて","300　闇を彷徨う","301　行く手をはばむ鋼の床","302　暗がりがくれた安らぎ","303　四輪の塔","304　レイストン要塞","305　虚ろなる光の封土","310　隠された真の姿","311　潜入","312　浮遊都市リベルアーク","313　その先を目指して","314　中枢塔《アクシスピラー》","315　★効果音★","316　仲間の元へ","320◆翡翠回廊 ","321◆異界","322◆金の道、銀の道","323◆光と影の迷宮","324◆深淵","325◆幻影城 《Phantasmagoria》","330◆宵闇の王城","331◆動かぬ世界","332◆虎穴に入りて虎児を得よ","333◆幻影の蒼い花","334◆黒の方舟","400　Sophisticated Fight","402　To be Suggestive","403　銀の意志","404　Challenger Invited","405　Ancient Makes","406　至宝を守護せしモノ","407　撃破！！","408　消え行く星","410　ピンチ！！","420　Strepitoso Fight","421　The Fate Of The Fairies","422　Obstructive Existence","423　Fight with Assailant","424　大いなる畏怖","425A Maybe It Was Fated Instrumental Ver.","426　Outskirts of Evolution","427　The Merciless Savior","428　雷の穿つ墓標","429　Feeling Danger Nearby","430◆Determination of Fight","431◆Fighting Right On","432◆Close to the Brink","433◆Overdosing Heavenly Bliss","434◆Genuine Devil","435◆夢と喧騒の聖地","436◆Banquet of frenzy","437◆Masquerade of Lies","438◆これが真の実力や！","439◆女神よ、お慈悲を・・・","440◆夢と喧騒の聖地(リトライ)","500　星の在り処 Harmonica short Ver.","501　琥珀の愛 Hum Ver.","502　琥珀の愛 Piano Ver.","503　琥珀の愛 Lute Ver.","504　星の在り処 Harmonica long Ver.","505　賑やかに行こう","510　去り行く決意","511　暗躍する者たち","512　奴を逃がすな！","513　胸の中に","514　月明りの下で","516　忍び寄る危機","517　俺達カプア一家！","518　旅立ちの小径","519　奪還","520　呪縛からの解放、そして・・・","521　告白","522　黒のオーブメント","523　リベールの誇り","530　(劇)姫の悩み","531　(劇)騎士達の嘆き","532　(劇)それぞれの思惑","533　(劇)城","534　(劇)コロシアム","535　(劇)決闘","536　(劇)姫の死","537　(劇)大団円","540　陰謀","541　執行者","542　福音計画","543　迫りくる脅威","544　ハーメル","546　うちひしがれて","547　荒野に潜む影","548　夢の続き","549　絆の在り処","550　銀の意志 Super Arrange Ver","551　星の在り処 Instrumental ver","552　Etude of the Ruin","554　惨劇の真相","556　夢幻","560◆飛行客船ルシタニア号","561◆強襲","562◆招かれざる者","563◆大切なもの","564◆追憶","565◆煉獄への階段","566◆影の王","567◆Cry for your Eternity","568◆想いの眠るゆりかご","569◆またいつか会うために","570◆君を忘れてた","571◆The Crimson Stigma","572◆星の扉14","573◆始まりの地","574◆レクルスの方石","581◆女神の機嫌は時の運","582◆爆釣王よ永遠に","583◆空の謎は軌跡でポン！","584◆山猫号反攻作戦","586◆Till the Night of Glory","★FALCOMロゴ動画","★オープニング動画","★エンディング動画","★動画1","★動画2","★動画3"}


text:
{ if (pthread_create(thp, NULL, func, (void *) argp) != 0) { fprintf(stderr, "cdft thread error\n"); exit(1); } }


text:
{ DWORD thid; *(thp) = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) func, (LPVOID) argp, 0, &thid); if (*(thp) == 0) { fprintf(stderr, "cdft thread error\n"); exit(1); } }


text:
= {"bgm01 ぐるぐるTonight","bgm08 オバケな日々","bgm03 あなたはだぁれ？","bgm05 マイペースなオバケたち","bgm06 ディース商店街のテーマ","bgm04 宴の館","bgm09 たたた大変でしゅ","bgm11 EURO BEAT POCO","bgm15 伝説のドリル","bgm07 オバケワールド","bgm36 ステージクリア","bgm12 闇の霧","bgm14 なんだか大変！？","bgm10 Animal Minimal","bgm17 グルグル魔人でポン","bgm18 今来た道を戻れ","bgm43 無敵の鎧は絶対破れマセ～ン！","bgm21 マイナスイオンの静寂","bgm27 秘密の密林サバイバル","bgm22 dance in the forest","bgm23 虹色オバケは泳げない","bgm24 sight of silence","bgm25 SAMURAI DRILL！","bgm20 JunJun - Jungle gym","bgm26 under the sky","bgm28 bomber girl","bgm39 おもひで","bgm29 不可思議オバケ卵","bgm30 Blest of Wind","bgm45 Rocky Nebula","bgm31 復習の賛歌","bgm46 呪われし厄の牙","bgm32 悲しき蒼穹を翔ける","bgm38 やるしかないわね！","bgm35 戦い終わって日が暮れて","bgm40 明日はきっとみんな友達","bgm42 いつもの場所へ","bgm02 Friends","bgm33 TO MAKE THE END OF DIGING","bgm44 ディース商店街の歌","★オープニング"}


text:
= {"Blues","Classic Rock","Country","Dance","Disco","Funk","Grunge","Hip-Hop","Jazz","Metal","New Age","Oldies","Other","Pop","R&B","Rap","Reggae","Rock","Techno","Industrial","Alternative","Ska","Death Metal","Pranks","Soundtrack","Euro-Techno","Ambient","Trip-Hop","Vocal","Jazz+Funk","Fusion","Trance","Classical","Instrumental","Acid","House","Game","Sound Clip","Gospel","Noise","Alt. Rock","Bass","Soul","Punk","Space","Meditative","Instrumental Pop","Instrumental Rock","Ethnic","Gothic","Darkwave","Techno-Industrial","Electronic","Pop-Folk","Eurodance","Dream","Southern Rock","Comedy","Cult","Gangsta Rap","Top 40","Christian Rap","Pop/Funk","Jungle","Native American","Cabaret","New Wave","Psychedelic","Rave","Showtunes","Trailer","Lo-Fi","Tribal","Acid Punk","Acid Jazz","Polka","Retro","Musical","Rock & Roll","Hard Rock","Folk","Folk/Rock","National Folk","Swing","Fast-Fusion","Bebob","Latin","Revival","Celtic","Bluegrass","Avantgarde","Gothic Rock","Progressive Rock","Psychedelic Rock","Symphonic Rock","Slow Rock","Big Band","Chorus","Easy Listening","Acoustic","Humour","Speech","Chanson","Opera","Chamber Music","Sonata","Symphony","Booty Bass","Primus","Porn Groove","Satire","Slow Jam","Club","Tango","Samba","Folklore","Ballad","Power Ballad","Rhythmic Soul","Freestyle","Duet","Punk Rock","Drum Solo","A Cappella","Euro-House","Dance Hall","Goa","Drum & Bass","Club-House","Hardcore","Terror","Indie","BritPop","Negerpunk","Polsk Punk","Beat","Christian Gangsta Rap","Heavy Metal","Black Metal","Crossover","Contemporary Christian","Christian Rock","Merengue","Salsa","Thrash Metal","Anime","JPop","Synthpop","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Heavy Rock(J)","Doom Rock(J)","J-POP(J)","Seiyu(J)","Tecno Ambient(J)","Moemoe(J)","Tokusatsu(J)","Anime(J)"}


text:
= {{"AENC","CRA"},{"APIC","PIC"},{"COMM","COM"},{"EQUA","EQU"},{"ETCO","ETC"},{"GEOB","GEO"},{"IPLS","IPL"},{"MCDI","MCI"},{"MLLT","MLL"},{"PCNT","CNT"},{"POPM","POP"},{"RBUF","BUF"},{"RVAD","RVA"},{"RVRB","REV"},{"SYLT","SLT"},{"SYTC","STC"},{"TALB","TAL"},{"TBPM","TBP"},{"TCOM","TCM"},{"TCON","TCO"},{"TCOP","TCR"},{"TDAT","TDA"},{"TDLY","TDY"},{"TENC","TEN"},{"TFLT","TFT"},{"TIME","TIM"},{"TIT1","TT1"},{"TIT2","TT2"},{"TIT3","TT3"},{"TKEY","TKE"},{"TLAN","TLA"},{"TLEN","TLE"},{"TMED","TMT"},{"TOAL","TOT"},{"TOFN","TOF"},{"TOLY","TOL"},{"TOPE","TOA"},{"TORY","TOR"},{"TPE1","TP1"},{"TPE2","TP2"},{"TPE3","TP3"},{"TPE4","TP4"},{"TPOS","TPA"},{"TPUB","TPB"},{"TRCK","TRK"},{"TRDA","TRD"},{"TSIZ","TSI"},{"TSRC","TRC"},{"TSSE","TSS"},{"TYER","TYE"},{"TXXX","TXX"},{"UFID","UFI"},{"USLT","ULT"},{"WCOM","WCM"},{"WCOP","WCP"},{"WOAF","WAF"},{"WOAR","WAR"},{"WOAS","WAS"},{"WPUB","WPB"},{"WXXX","WXX"},{NULL,NULL}}


text:
= {"001 --/SC 風を共に舞う気持ち SC Ver","010 --/SC Shine of Eidos ～空の軌跡～","011 --/SC OP 銀の意志 金の翼/山脇宏子","012 --/SC ED I swear.../小寺可南子","015 --/SC 解き放たれた至宝","016 --/SC 女神の御許へ","017 --/SC 折られた翼","018 --/SC 希望の行方","100 FC/SC 地方都市ロレント","101 FC/SC 商業都市ボース","102 FC/SC 海港都市ルーアン","103 FC/SC 工房都市ツァイス","104 FC/SC 王都グランセル","105 FC/SC 陽だまりにて和む猫","106 FC/SC 国境警備も楽じゃない","107 FC/SC 王城","108 FC/SC グランアリーナ","110 --/SC ル＝ロックルへようこそ","111 --/SC 灯火が消えた街","112 --/SC Heartless Surprise Attack","113 --/SC 飛行戦艦グロリアス","200 FC/-- リベールの歩き方","201 FC/SC Secret Green Passage","202 FC/SC Rock on the Road","210 --/SC 空を見上げて","300 FC/SC 闇を彷徨う","301 FC/SC 行く手をはばむ鋼の床","302 FC/SC 暗がりがくれた安らぎ","303 FC/SC 四輪の塔","304 FC/SC レイストン要塞","305 FC/-- 虚ろなる光の封土","310 --/SC 隠された真の姿","311 --/SC 潜入","312 --/SC 浮遊都市リベルアーク","313 --/SC その先を目指して","314 --/SC 中枢塔《アクシスピラー》","315 --/SC ★効果音★","316 --/SC 仲間の元へ","400 FC/-- Sophisticated Fight","402 FC/SC To be Suggestive","403 FC/SC 銀の意志","404 FC/SC Challenger Invited","405 FC/-- Ancient Makes","406 FC/-- 至宝を守護せしモノ","407 FC/SC 撃破！！","408 FC/SC 消え行く星","410 FC/SC ピンチ！！","420 --/SC Strepitoso Fight","421 --/SC The Fate Of The Fairies","422 --/SC Obstructive Existence","423 --/SC Fight with Assailant","424 --/SC 大いなる畏怖","425 --/SC Fateful confrontation","426 --/SC Outskirts of Evolution","427 --/SC The Merciless Savior","428 --/SC 雷の穿つ墓標","429 --/SC Feeling Danger Nearby","500 FC/SC 星の在り処 Harmonica short Ver.","501 FC/-- 琥珀の愛 Hum Ver.","502 FC/-- 琥珀の愛 Piano Ver.","503 FC/-- 琥珀の愛 Lute Ver.","504 FC/-- 星の在り処 Harmonica long Ver.","505 FC/SC 賑やかに行こう","510 FC/SC 去り行く決意","511 FC/SC 暗躍する者たち","512 FC/-- 奴を逃がすな！","513 FC/SC 胸の中に","514 FC/SC 月明りの下で","516 FC/SC 忍び寄る危機","517 FC/-- 俺達カプア一家！","518 FC/-- 旅立ちの小径","519 FC/SC 奪還","520 FC/-- 呪縛からの解放、そして・・・","521 FC/SC 告白","522 FC/SC 黒のオーブメント","523 FC/SC リベールの誇り","530 FC/-- (劇)姫の悩み","531 FC/-- (劇)騎士達の嘆き","532 FC/-- (劇)それぞれの思惑","533 FC/-- (劇)城","534 FC/-- (劇)コロシアム","535 FC/-- (劇)決闘","536 FC/-- (劇)姫の死","537 FC/-- (劇)大団円","540 --/SC 陰謀","541 --/SC 執行者","542 --/SC 福音計画","543 --/SC 迫りくる脅威","544 --/SC ハーメル","546 --/SC うちひしがれて","547 --/SC 荒野に潜む影","548 --/SC 夢の続き","549 --/SC 絆の在り処","550 --/SC 銀の意志 Super Arrange Ver","551 --/SC 星の在り処 Instrumental ver","552 --/SC Etude of the Ruin","554 --/SC 惨劇の真相","556 --/SC 夢幻","★FALCOMロゴ動画","★オープニング動画","★エンディング動画","★動画1","★動画2","★動画3","★動画4","★動画5","★動画6","★動画7"}


text:
= {"001 風を共に舞う気持ち","100 地方都市ロレント","101 商業都市ボース","102 海港都市ルーアン","103 工房都市ツァイス","104 王都グランセル","105 陽だまりにて和む猫","106 国境警備も楽じゃない","107 王城","108 グランアリーナ","200 リベールの歩き方","201 Secret Green Passage","202 Rock on the Road","300 闇を彷徨う","301 行く手をはばむ鋼の床","302 暗がりがくれた安らぎ","303 四輪の塔","304 レイストン要塞","305 虚ろなる光の封土","400 Sophisticated Fight","402 To be Suggestive","403 銀の意志","404 Challenger Invited","405 Ancient Makes","406 至宝を守護せしモノ","407 撃破！！","408 消え行く星","410 ピンチ！！","500 星の在り処 Harmonica short Ver.","501 琥珀の愛 Hum Ver.","502 琥珀の愛 Piano Ver.","503 琥珀の愛 Lute Ver.","504 星の在り処 Harmonica long Ver.","505 賑やかに行こう","510 去り行く決意","511 暗躍する者たち","512 奴を逃がすな！","513 胸の中に","514 月明りの下で","516 忍び寄る危機","517 俺達カプア一家！","518 旅立ちの小径","519 奪還","520 呪縛からの解放、そして・・・","521 告白","522 黒のオーブメント","523 リベールの誇り","530 (劇)姫の悩み","531 (劇)騎士達の嘆き","532 (劇)それぞれの思惑","533 (劇)城","534 (劇)コロシアム","535 (劇)決闘","536 (劇)姫の死","537 (劇)大団円","★FALCOMロゴ動画","★オープニング動画","★エンディング動画","★次作予告動画"}


text:
= {"01.タイトル/ロード","02.オープニング(動画あり)","03.Ｆｉｎ","04.レダの集落","05.ショップ","06.クアテラ樹海","07.中ボス一般","08.海底参道","09.リモージュの港町","10.カナン平原","11.グラナヴァリス","12.忘却の遺跡","13.ゼメスの聖地","14.鍾乳洞・地下湖","15.襲撃","16.占拠中","17.ロムン軍艦（通常）","18.ロムン軍艦（脱出）","19.アルマの墳墓","20.ガルヴァ＝ロア戦","21.エルンスト戦","22.ナピシュテムの匣,螺旋回廊","23.ナピ核戦<第１段階>（ラスボス）","24.ナピ核戦<第２段階>（ラスボス）","25.スタッフロール","26.ムービー1（渦消滅～ロムン襲来）(動画あり)","27.ムービー2（ナピ復活）(動画あり)","28.ムービー3（ナピ崩壊）(動画あり)","29.ムービー4（エンディング1）(動画あり)","30.ゲームオーバー","30.ゲームオーバー"}


text:
= {"01.Dancing on the road(不明)","02.予感 ＝スティクス＝(メニュー)","03.貿易の街レドモント(レドモントの町)","04.静かな刻(長老などの家)","05.Welcome!!(お店)","06.冒険への序曲(マップ)","07.翼を持った少年(フィールドマップ)","08.Be careful(ティグレーの採石場)","09.漆黒の魔獣(ボス戦)","10.イルバーンズの遺跡(イルバーンズの遺跡)","11.灼熱の死闘(溶岩地帯)","12.暗黒の罠(ティグレーの採石場奥)","13.死神の電撃(ボス戦)","14.いっときの夢(ゲームオーバー)","15.厳格なる闘志(エルダーム山脈)","16.哀愁のトワイライト(レドモントの町 危機後)","17.バレスタイン城(バレスタイン城内)","18.慈愛の祈り(バレスタイン城聖堂)","19.光りの鍵(エンディング後)","20.時の封印(バレスタイン城時計塔)","21.破滅への鼓動(ジェノス島)","22.運命の塔(ジェノス島深部)","23.これを見よ！！(ニコラス戦)","24.最強の敵(ガルバラン戦)","25.旅立ちの朝(クリア後のレドモントの町)","26.Wanderers from Ys(エンディング(動画))","27.Dear My Brother(エレナ、チェスターとのイベント)","28.愛しのエレナ(エレナのテーマ)","29.Introduction!!(レドモントの町でのイベント)","30.The Theme of Chester(チェスターのテーマ)","31.Chop!!(ボス戦)","32.Believe in my heart(クリア直前のレドモントの町)","33.予感 ＝スティクス＝(オープニング(動画))","34.愛しのエレナ(ガルバラン島崩壊(動画))"}


text:
= {"001 タイトル<THE GUIDANCE OF A WHITE TOWER>","002 イベント0<BONDS WITH COMPANION>","003 ダームの塔24-25F<BEYOND THE BEGINNING>","004 ダームの塔01-05F<TOWER OF THE SHADOW OF DEATH>","005 ダームの塔06-09F<WATER PRISON>","006 ダームの塔10-13F<SCARLET TEMPEST>","007 ダームの塔14-17F<SILENT DESERT>","008 ダームの塔18-21F<SAMSARA AND PARAMNESIA>","009 ダームの塔22-24F<PRELUDE TO THE OMEN>","010 ダームの塔最上階<THE LAST MOMENT OF THE DARK>(トールのみ)","011 ボス戦1<TENSION>(ジェノクレス)","012 ラドの塔/鏡の間<DREAMING>","013 魔の通路 <DEVIL'S WIND>","014 ボス戦2<SCARS OF THE DIVINE WING>(ﾍﾞﾗｶﾞﾝﾀﾞｰ/ﾆｸﾞﾃｨﾙｶﾞｰ/ｹﾞﾗﾙﾃﾞｨ/ﾋﾟｸﾃｨﾓｽ/ｺﾝｽｸﾗｰﾄﾞ)","015 ボス戦3<OBORO>(ｳﾞｧｼﾞｭﾘｵﾝ/その他<魔>の一族)","016 ボス戦4<MY LORD, OUR BRAVE>(ザバ/ヨグレクス＆オムルガン)","017 ダレス戦<OVER DRIVE>","018 魔王ダーム戦<TERMINATION>(トールのみ)","019 イントロ(動画用)<PROLOGUE -Ys ORIGIN->","020 ロゴ(動画用)","021 ロダの樹<RODA>","022 <魔>の一族のテーマ<THE ROOT OF DARKNESS>","023 イベント1<CONFRONTATION>","024 イベント2<THE PAIN OF SEPARATION>","025 イベント3<MEMORY OF SALMON>","026 イベント4<FEENA>","027 銀のハーモニカ1","028 銀のハーモニカ2","029 銀のハーモニカ2'ルーVer","030 イベント5<FAIR SKIES>","031 イベント6<DETERMINATION>","032 オープニング(動画用)<GENESIS BEYOND THE BEGINNING OPENING VERSION>","033 エンディング1(動画用)<TO THE NEXT GENERATION>ユニカ・ユーゴ","034 エンディング2(動画用)<A NEW LEGENDARY OPENING>トール","035 イベント7<BELIEVING>","036 ゲームオーバー<SO MUCH FOR TODAY>","037 インストラクション1<MAGNIFICENCE>","038 インストラクション2<MOVEMENT OF WICKED ENERGY>","039 インストラクション3<DISAPPEARANCE OF THREAT>","040 ダームの塔最上階イベント<-Bonus track- GENESIS BEYOND THE BEGINNING>(トールのみ)","★FALCOMロゴ動画","★プロローグ動画","★オープニング動画","★インストラクション1","★インストラクション2","★インストラクション3","★エンディング動画1","★エンディング動画2"}


text:
= {{{0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,},{0,32,48,56,64,80,96,112,128,160,192,224,256,320,384,},{0,32,40,48,56,64,80,96,112,128,160,192,224,256,320,}},{{0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,},{0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,},{0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,}}}


text:
= {{{0,32,64,96,128,160,192,224,256,288,320,352,384,416,448},{0,32,48,56,64,80,96,112,128,160,192,224,256,320,384},{0,32,40,48,56,64,80,96,112,128,160,192,224,256,320}},{{0,32,48,56,64,80,96,112,128,144,160,176,192,224,256},{0,8,16,24,32,40,48,56,64,80,96,112,128,144,160},{0,8,16,24,32,40,48,56,64,80,96,112,128,144,160}}}


text:
= {"z001 Brieging(ゼフィールファルコン作戦会議)","z002 COOL FIELD(フィールド山岳地帯)","z003 ディアブロ(ディアブロ第二段階)","z004 ゲイシルシティ(街)","z005 破壊神の鼓動(ディアブロ第一段階)","z006 インフェルノ(インフェルノ監獄(開放作戦))","z007 イオリーン(アンタリア創世記ヒロインのテーマ)","z008 Waltz de…(回想～バーンスタイン邸)","z009 街 Part1(村のテーマ)","z010 お別れイベントシーン(メルセデス)","z011 街 Part2(町のテーマ","z012 犠牲(悲しいイベント)","z013 …ドレイク？(海賊の襲撃)","z014 戦闘(通常戦闘)","z015 Zephyr Falcon(解放軍ゼフィールファルコン)","z016 The wind of Memory(シラノとメルセデスのピアノ曲)","z017 砂漠(砂漠)","z018 Aquamarine(最終ダンジョン～海底遺跡)","z019 魔剣阿修羅(阿修羅との戦い)","z020 Decisive Battle(ボスバトル)","z021 陰謀(イベントシーン(悪役専用))","z022 Force Field(解放戦争フィールド)","z023 FUZZY(スタッフロール)","z024 It's time to BATTLE!(ボスバトル2)","z025 PEACE(村)","z026 Precious Memories(シラノの想い出)","z027 Sorrowful…(イベント(大体が、誰かが死んだあと))","z028 Subway Crisis(ダンジョン)","z029 軍都市(緊迫した町のテーマ)","z030 目覚め(最終バトル直前)","z031 b-e natural(ダンジョン)","z032 チェザレ -part1-(チェザレのテーマ(オルガン))","z033 チェザレ -part2-(ラストバトル)","z034 Fireroad(契約)","z035 Forth step towards plain(フィールド・森など)","z036 THE GREAT REPEAT(ゲームタイトル画面)","z037 闇(インフェルノ地下)","z038 Jungle 2 Jungle(バース島)","z039 Not natural but natural(無限ループダンジョン)","z041 The wind of Memory（オーケストラ･ミックス）(エンディングテーマ)","z042 迷い(公爵屋敷)","z050 The wind of Memory（フレーズ）(ピアノ弾き)"}


text:
= {7,8,9,10,11,12,13,14,16,17,19,21,23,25,28,31,34,37,41,45,50,55,60,66,73,80,88,97,107,118,130,143,157,173,190,209,230,253,279,307,337,371,408,449,494,544,598,658,724,796,876,963,1060,1166,1282,1411,1552,1707,1878,2066,2272,2499,2749,3024,3327,3660,4026,4428,4871,5358,5894,6484,7132,7845,8630,9493,10442,11487,12635,13899,15289,16818,18500,20350,22385,24623,27086,29794,32767}


text:
= {"42 永遠的旋律","01 古松居","27 緊迫","12 風動","48 破軍","49 戰闘49","39 悲訣","38 暗思量","47 幽谷潤","05 陌上仙郷","51 戰闘51","08 蜘蛛洞","03 臨江雨","02 市井榮華","35 笑笑","36 采飛揚","29 征途","50 戰闘50","07 功名路","22 鬼界戰闘","45 激戰","13 背水一戰","53 祭旗","14 飲幽恨","15 秋瑟涙","46 天涯魂夢","11 雲中境","19 戰場","10 江湖行","04 朱樓春宴","31 衝陣","30 戰火","21 歩歩為營","41 衷情","37 回首前塵","54 玄機","09 幻霧星霜","20 水寒淵","06 烽火紅顔","16 月蒼茫","32 登天","23 華夜曲","34 決戰千里","★盡頭","40 遙相憶","★オープニング","★動画","★ファルコムロゴ"}


text:
= {"41 主題曲：界線(日本語Ver)","41 主題曲：界線(中国Ver)","45 懸圃：瓊樓玉宇","44 大地圖：鴻鵠萬里","16 白馬寒潭：碧水洞天","12 無界縫細：流雲輕舟","01 召徳村：暁風","11 古皇宮藏道：寒冰夜","19 飛凰宮：戰飛凰","48 武將出場：萬夫莫敵","36 一般戰鬥2：談笑論劍","18 鬼界：黄泉夢地","34 浪漫愛情曲：月下寄情","08 沙暴廢坑","09 潼關水路：空山新雨","25 濮陽雷澤：暗夜驚雷","22 蕭關：潛影","20 射日坡：波瀾動","21 壽春：一夫當關","39 戰場頭目戰鬥：爭鋒","30 緊張2(大)：危機四伏","32 非慟：離愁恨","13 浮月林：清月幽林","33 哀愁：相思無盡","47 百花樓","15 臥雲榻：半日","03 洛陽：秋霜","23 下ヒ：英雄末路","07 鎮江：美人含笑","27 輕鬆俏皮","27 輕鬆しょう皮","28 搞笑","28 こう笑","29 小緊張","10 崆峴山：嵐舞","10 そうけん山：嵐舞","14 洛陽西郊棧道：轟","06 許都：征前曲","02 長安：出巡","38 戰場戰鬥：決勝","24 官渡：路關險","37 一般頭目戰鬥：對峙","26 天若宮：天若仙韻","04 小沛：春色","17 幽妍島：霓裳","46 皇宮：皇圖","05 徐州：軍陣","31 重大打撃：天倫夢斷","40 最終頭目戰鬥：探雲霄","42 插曲：情衷","56 暗思量(幻想三国志1)","60 笑笑(幻想三国志1)","★ファルコムロゴ","★宇峻奥汀ロゴ","★オープニング","35 (不明)"}


text:
= {"SSO001 オープニング","SSO002 城 (ここで逢えるね)","SSO003 町1","SSO004 町2","SSO008 トラベラーズ・イン","SSO059 シナリオクリア","SSO005 消えた王様の杖 ダンジョン","SSO006 消えた王様の杖 ヒドラ","SSO007 消えた王様の杖 生還","SSO009 失われたタリスマン 森","SSO010 失われたタリスマン 地下ダンジョン","SSO011 失われたタリスマン 神官テルヒチ","SSO012 失われたタリスマン サンド・マリボー","SSO013 ルシフェルの水門 地下ダンジョン","SSO014 ルシフェルの水門 クラーケン","SSO015 ルシフェルの水門 ブラディー・リバー","SSO016 呪われたオアシス 砂漠","SSO017 呪われたオアシス 砂の城","SSO018 呪われたオアシス ルワンとゴールド・ドラゴン","SSO019 盗賊達の塔 塔","SSO020 盗賊達の塔 地底","SSO021 盗賊達の塔 屋上","SSO022 盗賊達の塔 メジャー・デーモン","SSO023 盗賊達の塔 シャドー・ドラゴン","SSO024 盗賊達の塔 封印","SSO025 暗き沼の魔法使い 暗き沼","SSO026 暗き沼の魔法使い レッド・ドラゴン","SSO027 ロマンシア ロマンシア王国","SSO028 ロマンシア ロマンシア城","SSO029 ロマンシア アゾルバ王国","SSO030 ロマンシア ヴァイデス","SSO060 ロマンシア専用クリア","SSO031 紅玉の謎 森","SSO032 紅玉の謎 モス・ジャイアント","SSO033 紅玉の謎 平和な森","SSO034 暗黒の魔道士 ダンジョン","SSO035 暗黒の魔道士 ゲディス","SSO064 暗黒の魔道士 ゲディスII","SSO036 暗黒の魔道士 ブルー・ドラゴン","SSO037 呪われたクイーンマリー号 船内","SSO038 呪われたクイーンマリー号 上陸後","SSO039 呪われたクイーンマリー号 アーク・デーモン","SSO040 天の神々たち 村","SSO041 天の神々たち コンバット・シーン","SSO042 天の神々たち 天上界","SSO043 天の神々たち 竪琴","SSO044 天の神々たち エビル=シャーマン","SSO045 氷の洞窟 洞窟","SSO046 氷の洞窟 洞窟II","SSO047 氷の洞窟 エキム","SSO048 メデューサの首 森","SSO049 メデューサの首 村","SSO050 メデューサの首 メデューサ","SSO051 囚われた魔法使い 地下要塞","SSO052 囚われた魔法使い ファイヤー・エレメント","SSO053 不老長寿の水 生きている洞窟","SSO054 不老長寿の水 動く心臓","SSO055 不老長寿の水 ダブル=デビルス","SSO056 キング・ドラゴン","SSO057 エンディングI","SSO058 エンディングII","SSO066 新オープニング","SSO080 ある魔術師の失敗 鉱山の地底湖","SSO081 ある魔術師の失敗 アースエレメンタル","SSO083 真夜中に鐘は鳴る ランドル村","SSO084 真夜中に鐘は鳴る 教会","SSO085 真夜中に鐘は鳴る ザキュレイア","SSO086 真夜中に鐘は鳴る 魔術士ゲラン","SSO087 ドワーフの置き土産 ドワーフの迷宮","SSO088 ドワーフの置き土産 ラビリンス・ドラゴン","SSO089 妖精の大樹を救え 妖精たちの村","SSO090 妖精の大樹を救え 巨大樹木内部","SSO091 妖精の大樹を救え センティピード","SSO092 招かれざる来訪者 怪しげな島","SSO093 招かれざる来訪者 アーク・デーモン","SSO082 フォーエバー シナリオ１～５クリア"}


text:
= {"Mc000 愛的廃墟","Mc001 幽謐","Mc003 歡潮","Mc011 暢游","Mc002 詭影","Mc013 月泉","Mc014 山雨欲來","Mc004 絲路（鼓鈴）","Mc015 踏春","Mc005 快板小調／滑稽小調","Mc016 夢魘","Mc006 追思","Mc017 暮歸","Mc007 離情","Mc018 空山","Mc008 秋夜","Mc019 塵思","Mc020 密殺","Mc021 埋伏","Mc022 決戰","Mc012 嬉戲","Mc023 忘憂","Mc024 天國梵音","Mc025 激殺","Mc026 怒殺","Mc027 血戰","Mc028 刃敵","Mc075 (不明)","★ファルコムロゴ","★オープニング","★スタッフロール","★エンディング１","★エンディング２","★エンディング３","★動画１","★動画２","★動画３","★動画４","★動画５"}


text:
= {"003 Two love","000 LA VALSE POUR XANADU～XANADU NEXT OPENING","004 Harlech","010 LA VALSE POUR XANADU～XANADU NEXT FIELD","030 The Eternal Maze","020 Clover Ruins","100 LA VALSE POUR XANADU～XANADU NEXT BATTLE","040 Egret Mountains","050 The Treacherous Woods","330 LA VALSE POUR XANADU～XANADU NEXT INTERMISSION","070 Xanadu Labyrinth","340 The One","080 Time Crevice","110 Bump in the road","090 The Castle of Strange Rock","320 Beginning of the Rock","200 Devil adent","210 evildoer","310 True Intent","001 Two love～Eternity","002 White Lie in Black","350 Two live～Requiem","300 LA VALSE POUR XANADU～XANADU NEXT EVENT","060 The Eternal Maze","★ファルコムロゴ","★オープニング"}


text:
= {"YS1&2OP","ys100 Ys -Opening-","ys101 FEENA","ys102 FOUNTAIN OF LOVE","ys103 THE SYONIN","ys104 TEARS OF SYLPH","ys105 FIRST STEP TOWARDS WARS","ys106 PALACE","ys107 HOLDERS OF POWER","ys108 PALACE OF DESTRUCTION","ys109 BEAT OF THE TERROR","ys110 TOWER OF THE SHADOW OF DEATH","ys111 THE LAST MOMENT OF THE DARK","ys112 FINAL BATTLE","ys113 REST IN PEACE","ys114 THE MORNING GROW","ys115 SEE YOU AGAIN","ys134 DEVIL'S WIND","ys135 SO MUCH FOR TODAY","ys137 RODA","ys138 DEPARTURE","ys139 OPEN YOUR HEART","ys140 DREAMING","ys141 TENSION","ys142 CHASE OF SHADOW","★オープニング"}


text:
= {"01ys248 TO MAKE THE END OF BATTLE","02ys236 LILIA","03ys205 TOO FULL WITH LOVE","04ys225 APATHETIC STORY","05ys226 MAY I HELP YOU","06ys228 FEEL BLUE","07ys201 RUINS OF MOONDORIA","08ys220 NOBLE DISTRICT OF TOAL","09ys249 REST IN PEACE","10ys241 CAVERN OF RASTEENIE","11ys244 PROTECTERS","12ys242 ICE RIDGE OF NOLTIA","13ys203 INSIDE OF THE ICE WALL","14ys243 MOAT OF BURNEBLESS","15ys232 TENDER PEOPLE","16ys240 PALACE OF SALMON","17ys233 SUBTERRANEAN CANAL","18ys245 COMPANILE OF LANE","19ys223 PRESSURE ROAD","20ys235 DON'T GO SO SMOOTHLY!","21ys234 FEENA","22ys246 TERMINATION","23ys221 A STILL TIME","24ys207 STAY WITH ME FOREVER","25ys218 SO MUCH FOR TODAY","26ysn001COLONY OF LAVA","27ysi001OPEN YOUR HEART","28yss003FEENA","29ys124 BATTLE GROUND","30ys121 OVER DRIVE","31ys116 FAIR WIND","★オープニング1","★オープニング2"}


text:
= {"p_00ys1 [PC88] Ys -Opening-","p_01ys1 [PC88] FEENA","p_02ys1 [PC88] FOUNTAIN OF LOVE","p_03ys1 [PC88] THE SYONIN","p_04ys1 [PC88] TEARS OF SYLPH","p_05ys1 [PC88] FIRST STEP TOWARDS WARS","p_06ys1 [PC88] PALACE","p_07ys1 [PC88] HOLDERS OF POWER","p_08ys1 [PC88] PALACE OF DESTRUCTION","p_09ys1 [PC88] BEAT OF THE TERROR","p_10ys1 [PC88] TOWER OF THE SHADOW OF DEATH","p_11ys1 [PC88] THE LAST MOMENT OF THE DARK","p_12ys1 [PC88] FINAL BATTLE","p_13ys1 [PC88] REST IN PEACE","p_14ys1 [PC88] THE MORNING GROW","p_15ys1 [PC88] SEE YOU AGAIN","p_34ys1 [PC88] DEVIL'S WIND","p_35ys1 [PC88] SO MUCH FOR TODAY","p_37ys1 [PC88] RODA","p_38ys1 [PC88] DEPARTURE","p_39ys1 [PC88] OPEN YOUR HEART","p_40ys1 [PC88] DREAMING","p_41ys1 [PC88] TENSION","p_42ys1 [PC88] CHASE OF SHADOW","o_00ys1 [Eternal] Ys -Opening-","o_01ys1 [Eternal] FEENA","o_02ys1 [Eternal] FOUNTAIN OF LOVE","o_03ys1 [Eternal] THE SYONIN","o_04ys1 [Eternal] TEARS OF SYLPH","o_05ys1 [Eternal] FIRST STEP TOWARDS WARS","o_06ys1 [Eternal] PALACE","o_07ys1 [Eternal] HOLDERS OF POWER","o_08ys1 [Eternal] PALACE OF DESTRUCTION","o_09ys1 [Eternal] BEAT OF THE TERROR","o_10ys1 [Eternal] TOWER OF THE SHADOW OF DEATH","o_11ys1 [Eternal] THE LAST MOMENT OF THE DARK","o_12ys1 [Eternal] FINAL BATTLE","o_13ys1 [Eternal] REST IN PEACE","o_14ys1 [Eternal] THE MORNING GROW","o_15ys1 [Eternal] SEE YOU AGAIN","o_34ys1 [Eternal] DEVIL'S WIND","o_35ys1 [Eternal] SO MUCH FOR TODAY","o_37ys1 [Eternal] RODA","o_38ys1 [Eternal] DEPARTURE","o_39ys1 [Eternal] OPEN YOUR HEART","o_40ys1 [Eternal] DREAMING","o_41ys1 [Eternal] TENSION","o_42ys1 [Eternal] CHASE OF SHADOW","ys100_44 [Chronicles] Ys -Opening-","ys101_44 [Chronicles] FEENA","ys102_44 [Chronicles] FOUNTAIN OF LOVE","ys103_44 [Chronicles] THE SYONIN","ys104_44 [Chronicles] TEARS OF SYLPH","ys105_44 [Chronicles] FIRST STEP TOWARDS WARS","ys106_44 [Chronicles] PALACE","ys107_44 [Chronicles] HOLDERS OF POWER","ys108_44 [Chronicles] PALACE OF DESTRUCTION","ys109_44 [Chronicles] BEAT OF THE TERROR","ys110_44 [Chronicles] TOWER OF THE SHADOW OF DEATH","ys111_44 [Chronicles] THE LAST MOMENT OF THE DARK","ys112_44 [Chronicles] FINAL BATTLE","ys113_44 [Chronicles] REST IN PEACE","ys114_44 [Chronicles] THE MORNING GROW","ys115_44 [Chronicles] Victory!!","ys134_44 [Chronicles] DEVIL'S WIND","ys135_44 [Chronicles] SO MUCH FOR TODAY","ys137_44 [Chronicles] RODA","ys138_44 [Chronicles] DEPARTURE","ys139_44 [Chronicles] OPEN YOUR HEART","ys140_44 [Chronicles] DREAMING","ys141_44 [Chronicles] TENSION","ys142_44 [Chronicles] CHASE OF SHADOW","★オープニング[PC88]","★オープニング[Eternal]","★オープニング[Chronicles]"}


text:
= {"p_01ys2 [PC88] TO MAKE THE END OF BATTLE","p_02ys2 [PC88] LILIA","p_03ys2 [PC88] TOO FULL WITH LOVE","p_04ys2 [PC88] APATHETIC STORY","p_05ys2 [PC88] MAY I HELP YOU","p_06ys2 [PC88] FEEL BLUE","p_07ys2 [PC88] RUINS OF MOONDORIA","p_08ys2 [PC88] NOBLE DISTRICT OF TOAL","p_09ys2 [PC88] REST IN PEACE","p_10ys2 [PC88] CAVERN OF RASTEENIE","p_11ys2 [PC88] PROTECTERS","p_12ys2 [PC88] ICE RIDGE OF NOLTIA","p_13ys2 [PC88] INSIDE OF THE ICE WALL","p_14ys2 [PC88] MOAT OF BURNEBLESS","p_15ys2 [PC88] TENDER PEOPLE","p_16ys2 [PC88] PALACE OF SALMON","p_17ys2 [PC88] SUBTERRANEAN CANAL","p_18ys2 [PC88] COMPANILE OF LANE","p_19ys2 [PC88] PRESSURE ROAD","p_20ys2 [PC88] DON'T GO SO SMOOTHLY!","p_21ys2 [PC88] FEENA","p_22ys2 [PC88] TERMINATION","p_23ys2 [PC88] A STILL TIME","p_24ys2 [PC88] STAY WITH ME FOREVER","p_25ys2 [PC88] SO MUCH FOR TODAY","p_26ys2 [PC88] COLONY OF LAVA","p_27ys2 [PC88] OPEN YOUR HEART","p_28ys2 [PC88] FEENA","p_29ys2 [PC88] BATTLE GROUND","p_30ys2 [PC88] OVER DRIVE","p_31ys2 [PC88] FAIR WIND","o_01ys2 [Eternal] TO MAKE THE END OF BATTLE","o_02ys2 [Eternal] LILIA","o_03ys2 [Eternal] TOO FULL WITH LOVE","o_04ys2 [Eternal] APATHETIC STORY","o_05ys2 [Eternal] MAY I HELP YOU","o_06ys2 [Eternal] FEEL BLUE","o_07ys2 [Eternal] RUINS OF MOONDORIA","o_08ys2 [Eternal] NOBLE DISTRICT OF TOAL","o_09ys2 [Eternal] REST IN PEACE","o_10ys2 [Eternal] CAVERN OF RASTEENIE","o_11ys2 [Eternal] PROTECTERS","o_12ys2 [Eternal] ICE RIDGE OF NOLTIA","o_13ys2 [Eternal] INSIDE OF THE ICE WALL","o_14ys2 [Eternal] MOAT OF BURNEBLESS","o_15ys2 [Eternal] TENDER PEOPLE","o_16ys2 [Eternal] PALACE OF SALMON","o_17ys2 [Eternal] SUBTERRANEAN CANAL","o_18ys2 [Eternal] COMPANILE OF LANE","o_19ys2 [Eternal] PRESSURE ROAD","o_20ys2 [Eternal] DON'T GO SO SMOOTHLY!","o_21ys2 [Eternal] FEENA","o_22ys2 [Eternal] TERMINATION","o_23ys2 [Eternal] A STILL TIME","o_24ys2 [Eternal] STAY WITH ME FOREVER","o_25ys2 [Eternal] SO MUCH FOR TODAY","o_26ys2 [Eternal] COLONY OF LAVA","o_27ys2 [Eternal] OPEN YOUR HEART","o_28ys2 [Eternal] FEENA","o_29ys2 [Eternal] BATTLE GROUND","o_30ys2 [Eternal] OVER DRIVE","o_31ys2 [Eternal] FAIR WIND","01ys248 [Chronicles] TO MAKE THE END OF BATTLE","02ys236 [Chronicles] LILIA","03ys205 [Chronicles] TOO FULL WITH LOVE","04ys225 [Chronicles] APATHETIC STORY","05ys226 [Chronicles] MAY I HELP YOU","06ys228 [Chronicles] FEEL BLUE","07ys201 [Chronicles] RUINS OF MOONDORIA","08ys220 [Chronicles] NOBLE DISTRICT OF TOAL","09ys249 [Chronicles] REST IN PEACE","10ys241 [Chronicles] CAVERN OF RASTEENIE","11ys244 [Chronicles] PROTECTERS","12ys242 [Chronicles] ICE RIDGE OF NOLTIA","13ys203 [Chronicles] INSIDE OF THE ICE WALL","14ys243 [Chronicles] MOAT OF BURNEBLESS","15ys232 [Chronicles] TENDER PEOPLE","16ys240 [Chronicles] PALACE OF SALMON","17ys233 [Chronicles] SUBTERRANEAN CANAL","18ys245 [Chronicles] COMPANILE OF LANE","19ys223 [Chronicles] PRESSURE ROAD","20ys235 [Chronicles] DON'T GO SO SMOOTHLY!","21ys234 [Chronicles] FEENA","22ys246 [Chronicles] TERMINATION","23ys221 [Chronicles] A STILL TIME","24ys207 [Chronicles] In Adventure World","25ys218 [Chronicles] SO MUCH FOR TODAY","26ysn001[Chronicles] COLONY OF LAVA","27ysi001[Chronicles] OPEN YOUR HEART","28yss003[Chronicles] FEENA","29ys124 [Chronicles] BATTLE GROUND","30ys121 [Chronicles] OVER DRIVE","31ys116 [Chronicles] FAIR WIND","★オープニング[PC88]","★オープニング[Eternal]","★オープニング[Chronicles]","★エンディング1a[PC88]","★エンディング1a[Eternal]","★エンディング1a[Chronicles]","★エンディング1b[PC88]","★エンディング1b[Eternal]","★エンディング1b[Chronicles]"}


text:
= {"bgm44 浮遊大陸アルジェス　-Instroduction-","bgm35 永劫の夢、大空の記憶 -Zwei!! 2人で大冒険-","bgm03 プック村","bgm01 浮遊大陸アルジェス -Main Theme-","bgm13 パーヴェル庭園","bgm12 カヤパの森","bgm06 クロップ洞窟","bgm07 ケノーピ火山","bgm70 浮遊大陸アルジェス -夢見る秘宝-","bgm72 コルベットのテーマ　-ネコ言うニャーッ!-","bgm27 Fight!! -壊してポックル-","bgm60 ひとときの休息を","bgm16 ダプネ砂漠","bgm18 ヒポリタの丘","bgm19 トリポカ湖","bgm21 プシュケの屋敷","bgm50 おやすみ","bgm10 妖精たちの村","bgm26 スピリ古代迷宮","bgm71 竜の眠る道","bgm14 アプリエス神殿","bgm15 エスピナ暗黒神殿","bgm08 幻の大地 セルペンティナ","bgm22 魔王の両腕 -ハンド-","bgm09 最後の闘い -魔王ヴェスパー","bgm74 安堵のメロディ","bgm36 花と風のうた","bgm30 ムービー1 -光への誘い-","bgm31 ムービー2 -闇への誘い-","bgm32 ムービー3 -降臨-","bgm33 ムービー4 -大樹-","bgm34 ムービー5 -崩壊-","bgm77 Zwei!!シューティング -遊んでピピロ-","bgm75 Theme of Adol 2001","bgm76 モナモ～ナ","boss  "}


text:
= {"000 限りなき冒険の新天地","001 グランヴァレンの伝説","002 ボクラノ未来 Opening Version","003 ZWEI II End Credit","004 力尽きても…","006 魔法大戦再び…","007 たすけてアルウェン Rushing in Version","008 宿縁の終焉","100 浮遊島《イルバード》","101 アルッテの町","102 アルッテ飛行場","103 ブランデーヶ丘","104 ロアルタ村","105 星降りの里","106 クリスタルバレー","108 魔女ラーライラ","109 覆面超人ギャランドゥ","200 セクンドゥム廃坑","201 オルディウム神殿","202 金闇の森","203 アウロン大鉄塔","205 闇夜に踊れ","206 ムーンブリア城","207 狂喜の牢獄","208 エスピナへ捧ぐ祈り","209 星ヶ峰","210 覚悟を決めて","211 月の世界《ルナ＝ムンドゥス》","212 螺旋要塞メルセデク","300 まかせろラグナ","301 唸れ！アンカーギア！！","304 真祖の力","305 我にひれ伏せ","306 我が主のために","307 この瞬間に全てを賭けて","308 障害を突破せよ","400 Dog Fight！！","401 不穏な空気","402 モンブランのテーマ","403 レッツ・エクササァイズ！！","404 激情に駆られて","405 ザハールの大望","406 最悪の事態","407 あたたかな想い","408 通い合う心と心","409 お食事は大熊猫楼で","410 機械仕掛けの少女","411 宿縁の少女","412 たすけてアルウェン","413 失意のラグナ","414 課せられた使命","415 かけがえのない日常","416 再会を誓って","417 夜空に佇む","500 音楽 Ys フェルガナの誓い(翼を持った少年)","501 音楽 Ys フェルガナの誓い(バレスタイン城)","502 音楽 Ys オリジン(BEYOND THE BEGINNING)","503 音楽 Ys オリジン(WATER PRISON)","504 音楽 Zwei!!(花と風のうた -arrange-)","505 音楽 Zwei!!(幻の大地 セルペンティナ)","506 音楽 空の軌跡FC(虚ろなる光の封土)","507 音楽 空の軌跡SC(The Fate of The Fairies)","508 音楽 空の軌跡The3rd(Overdosing Heavenly Bliss)","509 音楽 ぐるみん(不可思議オバケ卵)","510 音楽 ぐるみん(TO MAKE THE END OF DIGING)","★オープニング","★エンディング"}


text:
protected: virtual IDocument* CreateDocument() { CRuntimeClass* pDocRTC = RUNTIME_CLASS(classDocument); if (pDocRTC == NULL) { TRACE("Document class does not support dynamic creation."); return NULL; } classDocument* pDoc = DYNAMIC_DOWNCAST(classDocument, pDocRTC->CreateObject()); ASSERT_VALID(pDoc); return pDoc->GetAdapter(); }


text:
protected: static const AFX_MSGMAP* PASCAL GetThisMessageMap(); virtual const AFX_MSGMAP* GetMessageMap() const;


text:
PTM_WARNING_DISABLE template < typename type_name > const AFX_MSGMAP* theClass< type_name >::GetMessageMap() const { return GetThisMessageMap(); } template < typename type_name > const AFX_MSGMAP* PASCAL theClass< type_name >::GetThisMessageMap() { typedef theClass< type_name > ThisClass; typedef baseClass TheBaseClass; static const AFX_MSGMAP_ENTRY _messageEntries[] = {


text:
PTM_WARNING_DISABLE const AFX_MSGMAP* theClass::GetMessageMap() const { return GetThisMessageMap(); } const AFX_MSGMAP* PASCAL theClass::GetThisMessageMap() { typedef theClass ThisClass; typedef baseClass TheBaseClass; static const AFX_MSGMAP_ENTRY _messageEntries[] = {


text:
{0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 } }; static const AFX_MSGMAP messageMap = { &TheBaseClass::GetThisMessageMap, &_messageEntries[0] }; return &messageMap; } PTM_WARNING_RESTORE


text:
private: static const AFX_INTERFACEMAP_ENTRY _interfaceEntries[]; protected: static const AFX_INTERFACEMAP interfaceMap; static const AFX_INTERFACEMAP* PASCAL GetThisInterfaceMap(); virtual const AFX_INTERFACEMAP* GetInterfaceMap() const;


text:
private: static const AFX_INTERFACEMAP_ENTRY _interfaceEntries[]; protected: static const AFX_INTERFACEMAP interfaceMap; virtual const AFX_INTERFACEMAP* GetInterfaceMap() const;


text:
theClass* pThis = ((theClass*)((BYTE*)this - offsetof(theClass, m_x##localClass))); AFX_MANAGE_STATE(pThis->m_pModuleState) pThis;


text:
class X##localClass : public baseClass { public: STDMETHOD_(ULONG, AddRef)(); STDMETHOD_(ULONG, Release)(); STDMETHOD(QueryInterface)(REFIID iid, LPVOID* ppvObj);


text:
const AFX_INTERFACEMAP* PASCAL theClass::GetThisInterfaceMap() { return &theClass::interfaceMap; } const AFX_INTERFACEMAP* theClass::GetInterfaceMap() const { return &theClass::interfaceMap; } AFX_COMDAT const AFX_INTERFACEMAP theClass::interfaceMap = { &theBase::GetThisInterfaceMap, &theClass::_interfaceEntries[0], }; AFX_COMDAT const AFX_INTERFACEMAP_ENTRY theClass::_interfaceEntries[] = {


text:
const AFX_INTERFACEMAP* theClass::GetInterfaceMap() const { return &theClass::interfaceMap; } AFX_COMDAT const AFX_INTERFACEMAP theClass::interfaceMap = { &theBase::interfaceMap, &theClass::_interfaceEntries[0], }; AFX_COMDAT const AFX_INTERFACEMAP_ENTRY theClass::_interfaceEntries[] = {


text:
private: static const AFX_DISPMAP_ENTRY _dispatchEntries[]; static UINT _dispatchEntryCount; static DWORD _dwStockPropMask; protected: static const AFX_DISPMAP dispatchMap; static const AFX_DISPMAP* PASCAL GetThisDispatchMap(); virtual const AFX_DISPMAP* GetDispatchMap() const;


text:
private: static const AFX_DISPMAP_ENTRY _dispatchEntries[]; static UINT _dispatchEntryCount; static DWORD _dwStockPropMask; protected: static const AFX_DISPMAP dispatchMap; virtual const AFX_DISPMAP* GetDispatchMap() const;


text:
private: static const AFX_OLECMDMAP_ENTRY _commandEntries[]; protected: static const AFX_OLECMDMAP commandMap; static const AFX_OLECMDMAP* PASCAL GetThisCommandMap(); virtual const AFX_OLECMDMAP* GetCommandMap() const;


text:
private: static const AFX_OLECMDMAP_ENTRY _commandEntries[]; protected: static const AFX_OLECMDMAP commandMap; virtual const AFX_OLECMDMAP* GetCommandMap() const;


text:
const AFX_OLECMDMAP* PASCAL theClass::GetThisCommandMap() { return &theClass::commandMap; } const AFX_OLECMDMAP* theClass::GetCommandMap() const { return &theClass::commandMap; } AFX_COMDAT const AFX_OLECMDMAP theClass::commandMap = { &baseClass::GetThisCommandMap, &theClass::_commandEntries[0] }; AFX_COMDAT const AFX_OLECMDMAP_ENTRY theClass::_commandEntries[] = {


text:
const AFX_OLECMDMAP* theClass::GetCommandMap() const { return &theClass::commandMap; } AFX_COMDAT const AFX_OLECMDMAP theClass::commandMap = { &baseClass::commandMap, &theClass::_commandEntries[0] }; AFX_COMDAT const AFX_OLECMDMAP_ENTRY theClass::_commandEntries[] = {


text:
private: static const AFX_EVENTSINKMAP_ENTRY _eventsinkEntries[]; static UINT _eventsinkEntryCount; protected: static const AFX_EVENTSINKMAP eventsinkMap; static const AFX_EVENTSINKMAP* PASCAL GetThisEventSinkMap(); virtual const AFX_EVENTSINKMAP* GetEventSinkMap() const;


text:
private: static const AFX_EVENTSINKMAP_ENTRY _eventsinkEntries[]; static UINT _eventsinkEntryCount; protected: static const AFX_EVENTSINKMAP eventsinkMap; virtual const AFX_EVENTSINKMAP* GetEventSinkMap() const;


text:
private: static const AFX_CONNECTIONMAP_ENTRY _connectionEntries[]; protected: static const AFX_CONNECTIONMAP connectionMap; static const AFX_CONNECTIONMAP* PASCAL GetThisConnectionMap(); virtual const AFX_CONNECTIONMAP* GetConnectionMap() const;


text:
private: static const AFX_CONNECTIONMAP_ENTRY _connectionEntries[]; protected: static const AFX_CONNECTIONMAP connectionMap; virtual const AFX_CONNECTIONMAP* GetConnectionMap() const;


text:
AFX_RESTART_MANAGER_SUPPORT_RESTART | AFX_RESTART_MANAGER_SUPPORT_RECOVERY | AFX_RESTART_MANAGER_REOPEN_PREVIOUS_FILES


text:
AFX_RESTART_MANAGER_SUPPORT_NO_AUTOSAVE | AFX_RESTART_MANAGER_AUTOSAVE_AT_RESTART | AFX_RESTART_MANAGER_AUTOSAVE_AT_INTERVAL | AFX_RESTART_MANAGER_RESTORE_AUTOSAVED_FILES


text:
AFX_RESTART_MANAGER_SUPPORT_RESTART | AFX_RESTART_MANAGER_AUTOSAVE_AT_RESTART | AFX_RESTART_MANAGER_REOPEN_PREVIOUS_FILES | AFX_RESTART_MANAGER_RESTORE_AUTOSAVED_FILES


text:
AFX_RESTART_MANAGER_SUPPORT_RECOVERY | AFX_RESTART_MANAGER_AUTOSAVE_AT_INTERVAL | AFX_RESTART_MANAGER_REOPEN_PREVIOUS_FILES | AFX_RESTART_MANAGER_RESTORE_AUTOSAVED_FILES


text:
((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))


text:
(JOY_RETURNX | JOY_RETURNY | JOY_RETURNZ | JOY_RETURNR | JOY_RETURNU | JOY_RETURNV | JOY_RETURNPOV | JOY_RETURNBUTTONS)


text:
__pragma(warning(suppress:6334))(sizeof ((_Val) + (float)0) == sizeof (float) ? 'f' : sizeof ((_Val) + (double)0) == sizeof (double) ? 'd' : 'l')


text:
(_CLASS_ARG(_Val) == 'f' ? _FFunc((float)(_Val)) : _CLASS_ARG(_Val) == 'd' ? _DFunc((double)(_Val)) : _LDFunc((long double)(_Val)))


text:
(_CLASS_ARG((_Val1) + (_Val2)) == 'f' ? _FFunc((float)(_Val1), (float)(_Val2)) : _CLASS_ARG((_Val1) + (_Val2)) == 'd' ? _DFunc((double)(_Val1), (double)(_Val2)) : _LDFunc((long double)(_Val1), (long double)(_Val2)))


text:
( (This)->lpVtbl -> GetAvailableVideoProcessorModes(This,lpdwNumProcessingModes,ppVideoProcessingModes) )


text:
(void)( (!!(expr)) || (1 != _CrtDbgReportW(_CRT_ASSERT, _CRT_WIDE(__FILE__), __LINE__, NULL, L"%ls", msg)) || (_CrtDbgBreak(), 0) )


text:
{ _ASSERTE((expr)); if (!(expr)) { _invoke_watson(_CRT_WIDE(#expr), __FUNCTIONW__, __FILEW__, __LINE__, 0); } }


text:
= {(size_t(*)(void*,size_t,size_t,void*))fread,(int(*)(void*,ogg_int64_t,int))_ov_header_fseek_wrap,(int(*)(void*))fclose,(long(*)(void*))ftell}


text:
= {(size_t(*)(void*,size_t,size_t,void*))fread,(int(*)(void*,ogg_int64_t,int))_ov_header_fseek_wrap,(int(*)(void*))NULL,(long(*)(void*))ftell}


text:
= {(size_t(*)(void*,size_t,size_t,void*))fread,(int(*)(void*,ogg_int64_t,int))NULL,(int(*)(void*))fclose,(long(*)(void*))NULL}


text:
= {(size_t(*)(void*,size_t,size_t,void*))fread,(int(*)(void*,ogg_int64_t,int))NULL,(int(*)(void*))NULL,(long(*)(void*))NULL}


text:
(PKEY_Calendar_OptionalAttendeeAddresses,0xD55BAE5A,0x3892,0x417A,0xA6,0x49,0xC6,0xAC,0x5A,0xAA,0xEA,0xB3,100)


text:
(PKEY_Calendar_OptionalAttendeeNames,0x09429607,0x582D,0x437F,0x84,0xC3,0xDE,0x93,0xA2,0xB2,0x4C,0x3C,100)


text:
(PKEY_Calendar_OrganizerAddress,0x744C8242,0x4DF5,0x456C,0xAB,0x9E,0x01,0x4E,0xFB,0x90,0x21,0xE3,100)


text:
(PKEY_Calendar_RequiredAttendeeAddresses,0x0BA7D6C3,0x568D,0x4159,0xAB,0x91,0x78,0x1A,0x91,0xFB,0x71,0xE5,100)


text:
(PKEY_Calendar_RequiredAttendeeNames,0xB33AF30B,0xF552,0x4584,0x93,0x6C,0xCB,0x93,0xE5,0xCD,0xA2,0x9F,100)


text:
(PKEY_Communication_DateItemExpires,0x428040AC,0xA177,0x4C8A,0x97,0x60,0xF6,0xF7,0x61,0x22,0x7F,0x9A,100)


text:
(PKEY_Communication_FollowupIconIndex,0x83A6347E,0x6FE4,0x4F40,0xBA,0x9C,0xC4,0x86,0x52,0x40,0xD1,0xF4,100)


text:
(PKEY_Communication_HeaderItem,0xC9C34F84,0x2241,0x4401,0xB6,0x07,0xBD,0x20,0xED,0x75,0xAE,0x7F,100)


text:
(PKEY_Communication_SecurityFlags,0x8619A4B6,0x9F4D,0x4429,0x8C,0x0F,0xB9,0x96,0xCA,0x59,0xE3,0x35,100)


text:
(PKEY_Communication_TaskStatus,0xBE1A72C6,0x9A1D,0x46B7,0xAF,0xE7,0xAF,0xAF,0x8C,0xEF,0x49,0x99,100)


text:
(PKEY_Communication_TaskStatusText,0xA6744477,0xC237,0x475B,0xA0,0x75,0x54,0xF3,0x44,0x98,0x29,0x2A,100)


text:
(PKEY_Computer_DecoratedFreeSpace,0x9B174B35,0x40FF,0x11D2,0xA2,0x7E,0x00,0xC0,0x4F,0xC3,0x08,0x71,7)


text:
(PKEY_Contact_AssistantTelephone,0x9A93244D,0xA7AD,0x4FF8,0x9B,0x99,0x45,0xEE,0x4C,0xC0,0x9A,0xF6,100)


text:
(PKEY_Contact_BusinessAddressCity,0x402B5934,0xEC5A,0x48C3,0x93,0xE6,0x85,0xE8,0x6A,0x2D,0x93,0x4E,100)


text:
(PKEY_Contact_BusinessAddressCountry,0xB0B87314,0xFCF6,0x4FEB,0x8D,0xFF,0xA5,0x0D,0xA6,0xAF,0x56,0x1C,100)


text:
(PKEY_Contact_BusinessAddressPostalCode,0xE1D4A09E,0xD758,0x4CD1,0xB6,0xEC,0x34,0xA8,0xB5,0xA7,0x3F,0x80,100)


text:
(PKEY_Contact_BusinessAddressPostOfficeBox,0xBC4E71CE,0x17F9,0x48D5,0xBE,0xE9,0x02,0x1D,0xF0,0xEA,0x54,0x09,100)


text:
(PKEY_Contact_BusinessAddressState,0x446F787F,0x10C4,0x41CB,0xA6,0xC4,0x4D,0x03,0x43,0x55,0x15,0x97,100)


text:
(PKEY_Contact_BusinessAddressStreet,0xDDD1460F,0xC0BF,0x4553,0x8C,0xE4,0x10,0x43,0x3C,0x90,0x8F,0xB0,100)


text:
(PKEY_Contact_BusinessFaxNumber,0x91EFF6F3,0x2E27,0x42CA,0x93,0x3E,0x7C,0x99,0x9F,0xBE,0x31,0x0B,100)


text:
(PKEY_Contact_BusinessHomePage,0x56310920,0x2491,0x4919,0x99,0xCE,0xEA,0xDB,0x06,0xFA,0xFD,0xB2,100)


text:
(PKEY_Contact_BusinessTelephone,0x6A15E5A0,0x0A1E,0x4CD7,0xBB,0x8C,0xD2,0xF1,0xB0,0xC9,0x29,0xBC,100)


text:
(PKEY_Contact_CallbackTelephone,0xBF53D1C3,0x49E0,0x4F7F,0x85,0x67,0x5A,0x82,0x1D,0x8A,0xC5,0x42,100)


text:
(PKEY_Contact_CompanyMainTelephone,0x8589E481,0x6040,0x473D,0xB1,0x71,0x7F,0xA8,0x9C,0x27,0x08,0xED,100)


text:
(PKEY_Contact_HomeAddressCountry,0x08A65AA1,0xF4C9,0x43DD,0x9D,0xDF,0xA3,0x3D,0x8E,0x7E,0xAD,0x85,100)


text:
(PKEY_Contact_HomeAddressPostalCode,0x8AFCC170,0x8A46,0x4B53,0x9E,0xEE,0x90,0xBA,0xE7,0x15,0x1E,0x62,100)


text:
(PKEY_Contact_HomeAddressPostOfficeBox,0x7B9F6399,0x0A3F,0x4B12,0x89,0xBD,0x4A,0xDC,0x51,0xC9,0x18,0xAF,100)


text:
(PKEY_Contact_HomeAddressState,0xC89A23D0,0x7D6D,0x4EB8,0x87,0xD4,0x77,0x6A,0x82,0xD4,0x93,0xE5,100)


text:
(PKEY_Contact_HomeAddressStreet,0x0ADEF160,0xDB3F,0x4308,0x9A,0x21,0x06,0x23,0x7B,0x16,0xFA,0x2A,100)


text:
(PKEY_Contact_JA_CompanyNamePhonetic,0x897B3694,0xFE9E,0x43E6,0x80,0x66,0x26,0x0F,0x59,0x0C,0x01,0x00,2)


text:
(PKEY_Contact_JA_FirstNamePhonetic,0x897B3694,0xFE9E,0x43E6,0x80,0x66,0x26,0x0F,0x59,0x0C,0x01,0x00,3)


text:
(PKEY_Contact_JA_LastNamePhonetic,0x897B3694,0xFE9E,0x43E6,0x80,0x66,0x26,0x0F,0x59,0x0C,0x01,0x00,4)


text:
(PKEY_Contact_OtherAddressCity,0x6E682923,0x7F7B,0x4F0C,0xA3,0x37,0xCF,0xCA,0x29,0x66,0x87,0xBF,100)


text:
(PKEY_Contact_OtherAddressCountry,0x8F167568,0x0AAE,0x4322,0x8E,0xD9,0x60,0x55,0xB7,0xB0,0xE3,0x98,100)


text:
(PKEY_Contact_OtherAddressPostalCode,0x95C656C1,0x2ABF,0x4148,0x9E,0xD3,0x9E,0xC6,0x02,0xE3,0xB7,0xCD,100)


text:
(PKEY_Contact_OtherAddressPostOfficeBox,0x8B26EA41,0x058F,0x43F6,0xAE,0xCC,0x40,0x35,0x68,0x1C,0xE9,0x77,100)


text:
(PKEY_Contact_OtherAddressState,0x71B377D6,0xE570,0x425F,0xA1,0x70,0x80,0x9F,0xAE,0x73,0xE5,0x4E,100)


text:
(PKEY_Contact_OtherAddressStreet,0xFF962609,0xB7D6,0x4999,0x86,0x2D,0x95,0x18,0x0D,0x52,0x9A,0xEA,100)


text:
(PKEY_Contact_PrimaryAddressCity,0xC8EA94F0,0xA9E3,0x4969,0xA9,0x4B,0x9C,0x62,0xA9,0x53,0x24,0xE0,100)


text:
(PKEY_Contact_PrimaryAddressCountry,0xE53D799D,0x0F3F,0x466E,0xB2,0xFF,0x74,0x63,0x4A,0x3C,0xB7,0xA4,100)


text:
(PKEY_Contact_PrimaryAddressPostalCode,0x18BBD425,0xECFD,0x46EF,0xB6,0x12,0x7B,0x4A,0x60,0x34,0xED,0xA0,100)


text:
(PKEY_Contact_PrimaryAddressPostOfficeBox,0xDE5EF3C7,0x46E1,0x484E,0x99,0x99,0x62,0xC5,0x30,0x83,0x94,0xC1,100)


text:
(PKEY_Contact_PrimaryAddressState,0xF1176DFE,0x7138,0x4640,0x8B,0x4C,0xAE,0x37,0x5D,0xC7,0x0A,0x6D,100)


text:
(PKEY_Contact_PrimaryAddressStreet,0x63C25B20,0x96BE,0x488F,0x87,0x88,0xC0,0x9C,0x40,0x7A,0xD8,0x12,100)


text:
(PKEY_Contact_PrimaryEmailAddress,0x176DC63C,0x2688,0x4E89,0x81,0x43,0xA3,0x47,0x80,0x0F,0x25,0xE9,48)


text:
(PKEY_Identity_PrimaryEmailAddress,0xFCC16823,0xBAED,0x4F24,0x9B,0x32,0xA0,0x98,0x21,0x17,0xF7,0xFA,100)


text:
(PKEY_IdentityProvider_Picture,0x2425166F,0x5642,0x4864,0x99,0x2F,0x98,0xFD,0x98,0xF2,0x94,0xC3,100)


text:
(PKEY_IsDefaultNonOwnerSaveLocation,0x5D76B67F,0x9B3D,0x44BB,0xB6,0xAE,0x25,0xDA,0x4F,0x63,0x8A,0x67,5)


text:
(PKEY_ItemFolderPathDisplayNarrow,0xDABD30ED,0x0043,0x4789,0xA7,0xF8,0xD0,0x13,0xA4,0x73,0x66,0x22,100)


text:
(PKEY_ParentalRatingsOrganization,0xA7FE0840,0x1344,0x46F0,0x8D,0x37,0x52,0xED,0x71,0x2A,0x4B,0xF9,100)


text:
(PKEY_DeviceInterface_PrinterDriverDirectory,0x847C66DE,0xB8D6,0x4AF9,0xAB,0xC3,0x6F,0x4F,0x92,0x6B,0xC0,0x39,14)


text:
(PKEY_DeviceInterface_PrinterDriverName,0xAFC47170,0x14F5,0x498C,0x8F,0x30,0xB0,0xD1,0x9B,0xE4,0x49,0xC6,11)


text:
(PKEY_DeviceInterface_PrinterName,0x0A7B84EF,0x0C27,0x463F,0x84,0xEF,0x06,0xC5,0x07,0x00,0x01,0xBE,10)


text:
(PKEY_DeviceInterface_PrinterPortName,0xEEC7B761,0x6F94,0x41B1,0x94,0x9F,0xC7,0x29,0x72,0x0D,0xD1,0x3C,12)


text:
(PKEY_Devices_BatteryPlusCharging,0x49CD1F76,0x5626,0x4B17,0xA4,0xE8,0x18,0xB4,0xAA,0x1A,0x22,0x13,22)


text:
(PKEY_Devices_BatteryPlusChargingText,0x49CD1F76,0x5626,0x4B17,0xA4,0xE8,0x18,0xB4,0xAA,0x1A,0x22,0x13,23)


text:
(PKEY_Devices_Category_Desc_Singular,0x78C34FC8,0x104A,0x4ACA,0x9E,0xA4,0x52,0x4D,0x52,0x99,0x6E,0x57,91)


text:
(PKEY_Devices_CategoryGroup_Desc,0x78C34FC8,0x104A,0x4ACA,0x9E,0xA4,0x52,0x4D,0x52,0x99,0x6E,0x57,94)


text:
(PKEY_Devices_Category_Desc_Plural,0x78C34FC8,0x104A,0x4ACA,0x9E,0xA4,0x52,0x4D,0x52,0x99,0x6E,0x57,92)


text:
(PKEY_Devices_DeviceDescription1,0x78C34FC8,0x104A,0x4ACA,0x9E,0xA4,0x52,0x4D,0x52,0x99,0x6E,0x57,81)


text:
(PKEY_Devices_DeviceDescription2,0x78C34FC8,0x104A,0x4ACA,0x9E,0xA4,0x52,0x4D,0x52,0x99,0x6E,0x57,82)


text:
(PKEY_Devices_IsSoftwareInstalling,0x83DA6326,0x97A6,0x4088,0x94,0x53,0xA1,0x92,0x3F,0x57,0x3B,0x29,9)


text:
(PKEY_Devices_LaunchDeviceStageFromExplorer,0x78C34FC8,0x104A,0x4ACA,0x9E,0xA4,0x52,0x4D,0x52,0x99,0x6E,0x57,77)


text:
(PKEY_Devices_NetworkedTooltip,0x880F70A2,0x6082,0x47AC,0x8A,0xAB,0xA7,0x39,0xD1,0xA3,0x00,0xC3,152)


text:
(PKEY_Devices_Notification_LowBattery,0xC4C07F2B,0x8524,0x4E66,0xAE,0x3A,0xA6,0x23,0x5F,0x10,0x3B,0xEB,2)


text:
(PKEY_Devices_Notification_MissedCall,0x6614EF48,0x4EFE,0x4424,0x9E,0xDA,0xC7,0x9F,0x40,0x4E,0xDF,0x3E,2)


text:
(PKEY_Devices_Notification_NewMessage,0x2BE9260A,0x2012,0x4742,0xA5,0x55,0xF4,0x1B,0x63,0x8B,0x7D,0xCB,2)


text:
(PKEY_Devices_Notification_NewVoicemail,0x59569556,0x0A08,0x4212,0x95,0xB9,0xFA,0xE2,0xAD,0x64,0x13,0xDB,2)


text:
(PKEY_Devices_Notification_StorageFull,0xA0E00EE1,0xF0C7,0x4D41,0xB8,0xE7,0x26,0xA7,0xBD,0x8D,0x38,0xB0,2)


text:
(PKEY_Devices_Notification_StorageFullLinkText,0xA0E00EE1,0xF0C7,0x4D41,0xB8,0xE7,0x26,0xA7,0xBD,0x8D,0x38,0xB0,3)


text:
(PKEY_Devices_IsNotWorkingProperly,0x78C34FC8,0x104A,0x4ACA,0x9E,0xA4,0x52,0x4D,0x52,0x99,0x6E,0x57,83)


text:
(PKEY_Devices_SafeRemovalRequired,0xAFD97640,0x86A3,0x4210,0xB6,0x7C,0x28,0x9C,0x41,0xAA,0xBE,0x55,2)


text:
(PKEY_Devices_StorageFreeSpacePercent,0x49CD1F76,0x5626,0x4B17,0xA4,0xE8,0x18,0xB4,0xAA,0x1A,0x22,0x13,14)


text:
(PKEY_Document_MultimediaClipCount,0xD5CDD502,0x2E9C,0x101B,0x93,0x97,0x08,0x00,0x2B,0x2C,0xF9,0xAE,10)


text:
(PKEY_Document_PresentationFormat,0xD5CDD502,0x2E9C,0x101B,0x93,0x97,0x08,0x00,0x2B,0x2C,0xF9,0xAE,3)


text:
(PKEY_Document_TotalEditingTime,0xF29F85E0,0x4FF9,0x1068,0xAB,0x91,0x08,0x00,0x2B,0x27,0xB3,0xD9,10)


text:
(PKEY_GPS_DestBearingDenominator,0x7ABCF4F8,0x7C3F,0x4988,0xAC,0x91,0x8D,0x2C,0x2E,0x97,0xEC,0xA5,100)


text:
(PKEY_GPS_DestBearingNumerator,0xBA3B1DA9,0x86EE,0x4B5D,0xA2,0xA4,0xA2,0x71,0xA4,0x29,0xF0,0xCF,100)


text:
(PKEY_GPS_DestDistanceDenominator,0x9BC2C99B,0xAC71,0x4127,0x9D,0x1C,0x25,0x96,0xD0,0xD7,0xDC,0xB7,100)


text:
(PKEY_GPS_DestDistanceNumerator,0x2BDA47DA,0x08C6,0x4FE1,0x80,0xBC,0xA7,0x2F,0xC5,0x17,0xC5,0xD0,100)


text:
(PKEY_GPS_DestLatitudeDenominator,0x3A372292,0x7FCA,0x49A7,0x99,0xD5,0xE4,0x7B,0xB2,0xD4,0xE7,0xAB,100)


text:
(PKEY_GPS_DestLatitudeNumerator,0xECF4B6F6,0xD5A6,0x433C,0xBB,0x92,0x40,0x76,0x65,0x0F,0xC8,0x90,100)


text:
(PKEY_GPS_DestLongitudeDenominator,0x425D69E5,0x48AD,0x4900,0x8D,0x80,0x6E,0xB6,0xB8,0xD0,0xAC,0x86,100)


text:
(PKEY_GPS_DestLongitudeNumerator,0xA3250282,0xFB6D,0x48D5,0x9A,0x89,0xDB,0xCA,0xCE,0x75,0xCC,0xCF,100)


text:
(PKEY_GPS_ImgDirectionDenominator,0x10B24595,0x41A2,0x4E20,0x93,0xC2,0x57,0x61,0xC1,0x39,0x5F,0x32,100)


text:
(PKEY_GPS_ImgDirectionNumerator,0xDC5877C7,0x225F,0x45F7,0xBA,0xC7,0xE8,0x13,0x34,0xB6,0x13,0x0A,100)


text:
(PKEY_GPS_LongitudeDenominator,0xBE6E176C,0x4534,0x4D2C,0xAC,0xE5,0x31,0xDE,0xDA,0xC1,0x60,0x6B,100)


text:
(PKEY_Image_CompressedBitsPerPixel,0x364B6FA9,0x37AB,0x482A,0xBE,0x2B,0xAE,0x02,0xF6,0x0D,0x43,0x18,100)


text:
(PKEY_Image_CompressedBitsPerPixelDenominator,0x1F8844E1,0x24AD,0x4508,0x9D,0xFD,0x53,0x26,0xA4,0x15,0xCE,0x02,100)


text:
(PKEY_Image_CompressedBitsPerPixelNumerator,0xD21A7148,0xD32C,0x4624,0x89,0x00,0x27,0x72,0x10,0xF7,0x9C,0x0F,100)


text:
(PKEY_Image_HorizontalResolution,0x6444048F,0x4C8B,0x11D1,0x8B,0x70,0x08,0x00,0x36,0xB1,0x1A,0x03,5)


text:
(PKEY_LayoutPattern_ContentViewModeForBrowse,0xC9944A21,0xA406,0x48FE,0x82,0x25,0xAE,0xC7,0xE2,0x4C,0x21,0x1B,500)


text:
(PKEY_LayoutPattern_ContentViewModeForSearch,0xC9944A21,0xA406,0x48FE,0x82,0x25,0xAE,0xC7,0xE2,0x4C,0x21,0x1B,501)


text:
(PKEY_Media_CreatorApplicationVersion,0x64440492,0x4C8B,0x11D1,0x8B,0x70,0x08,0x00,0x36,0xB1,0x1A,0x03,28)


text:
(PKEY_Media_MetadataContentProvider,0x64440492,0x4C8B,0x11D1,0x8B,0x70,0x08,0x00,0x36,0xB1,0x1A,0x03,17)


text:
(PKEY_Media_SubscriptionContentId,0x9AEBAE7A,0x9644,0x487D,0xA9,0x2C,0x65,0x75,0x85,0xED,0x75,0x1A,100)


text:
(PKEY_Media_UniqueFileIdentifier,0x64440492,0x4C8B,0x11D1,0x8B,0x70,0x08,0x00,0x36,0xB1,0x1A,0x03,35)


text:
(PKEY_Message_AttachmentContents,0x3143BF7C,0x80A8,0x4854,0x88,0x80,0xE2,0xE4,0x01,0x89,0xBD,0xD0,100)


text:
(PKEY_Message_ConversationIndex,0xDC8F80BD,0xAF1E,0x4289,0x85,0xB6,0x3D,0xFC,0x1B,0x49,0x39,0x92,101)


text:
(PKEY_Music_ContentGroupDescription,0x56A3372E,0xCE9C,0x11D2,0x9F,0x0E,0x00,0x60,0x97,0xC6,0x86,0xF6,33)


text:
(PKEY_Music_SynchronizedLyrics,0x6B223B6A,0x162E,0x4AA9,0xB3,0x9F,0x05,0xD6,0x78,0xFC,0x6D,0x77,100)


text:
(PKEY_Photo_ApertureDenominator,0xE1A9A38B,0x6685,0x46BD,0x87,0x5E,0x57,0x0D,0xC7,0xAD,0x73,0x20,100)


text:
(PKEY_Photo_BrightnessDenominator,0x6EBE6946,0x2321,0x440A,0x90,0xF0,0xC0,0x43,0xEF,0xD3,0x24,0x76,100)


text:
(PKEY_Photo_BrightnessNumerator,0x9E7D118F,0xB314,0x45A0,0x8C,0xFB,0xD6,0x54,0xB9,0x17,0xC9,0xE9,100)


text:
(PKEY_Photo_CameraManufacturer,0x14B81DA1,0x0135,0x4D31,0x96,0xD9,0x6C,0xBF,0xC9,0x67,0x1A,0x99,271)


text:
(PKEY_Photo_CameraSerialNumber,0x14B81DA1,0x0135,0x4D31,0x96,0xD9,0x6C,0xBF,0xC9,0x67,0x1A,0x99,273)


text:
(PKEY_Photo_DigitalZoomDenominator,0x745BAF0E,0xE5C1,0x4CFB,0x8A,0x1B,0xD0,0x31,0xA0,0xA5,0x23,0x93,100)


text:
(PKEY_Photo_DigitalZoomNumerator,0x16CBB924,0x6500,0x473B,0xA5,0xBE,0xF1,0x59,0x9B,0xCB,0xE4,0x13,100)


text:
(PKEY_Photo_ExposureBiasDenominator,0xAB205E50,0x04B7,0x461C,0xA1,0x8C,0x2F,0x23,0x38,0x36,0xE6,0x27,100)


text:
(PKEY_Photo_ExposureBiasNumerator,0x738BF284,0x1D87,0x420B,0x92,0xCF,0x58,0x34,0xBF,0x6E,0xF9,0xED,100)


text:
(PKEY_Photo_ExposureIndexDenominator,0x93112F89,0xC28B,0x492F,0x8A,0x9D,0x4B,0xE2,0x06,0x2C,0xEE,0x8A,100)


text:
(PKEY_Photo_ExposureIndexNumerator,0xCDEDCF30,0x8919,0x44DF,0x8F,0x4C,0x4E,0xB2,0xFF,0xDB,0x8D,0x89,100)


text:
(PKEY_Photo_ExposureProgramText,0xFEC690B7,0x5F30,0x4646,0xAE,0x47,0x4C,0xAA,0xFB,0xA8,0x84,0xA3,100)


text:
(PKEY_Photo_ExposureTimeDenominator,0x55E98597,0xAD16,0x42E0,0xB6,0x24,0x21,0x59,0x9A,0x19,0x98,0x38,100)


text:
(PKEY_Photo_ExposureTimeNumerator,0x257E44E2,0x9031,0x4323,0xAC,0x38,0x85,0xC5,0x52,0x87,0x1B,0x2E,100)


text:
(PKEY_Photo_FlashEnergyDenominator,0xD7B61C70,0x6323,0x49CD,0xA5,0xFC,0xC8,0x42,0x77,0x16,0x2C,0x97,100)


text:
(PKEY_Photo_FlashEnergyNumerator,0xFCAD3D3D,0x0858,0x400F,0xAA,0xA3,0x2F,0x66,0xCC,0xE2,0xA6,0xBC,100)


text:
(PKEY_Photo_FNumberDenominator,0xE92A2496,0x223B,0x4463,0xA4,0xE3,0x30,0xEA,0xBB,0xA7,0x9D,0x80,100)


text:
(PKEY_Photo_FocalLengthDenominator,0x305BC615,0xDCA1,0x44A5,0x9F,0xD4,0x10,0xC0,0xBA,0x79,0x41,0x2E,100)


text:
(PKEY_Photo_FocalLengthNumerator,0x776B6B3B,0x1E3D,0x4B0C,0x9A,0x0E,0x8F,0xBA,0xF2,0xA8,0x49,0x2A,100)


text:
(PKEY_Photo_FocalPlaneXResolution,0xCFC08D97,0xC6F7,0x4484,0x89,0xDD,0xEB,0xEF,0x43,0x56,0xFE,0x76,100)


text:
(PKEY_Photo_FocalPlaneXResolutionDenominator,0x0933F3F5,0x4786,0x4F46,0xA8,0xE8,0xD6,0x4D,0xD3,0x7F,0xA5,0x21,100)


text:
(PKEY_Photo_FocalPlaneXResolutionNumerator,0xDCCB10AF,0xB4E2,0x4B88,0x95,0xF9,0x03,0x1B,0x4D,0x5A,0xB4,0x90,100)


text:
(PKEY_Photo_FocalPlaneYResolution,0x4FFFE4D0,0x914F,0x4AC4,0x8D,0x6F,0xC9,0xC6,0x1D,0xE1,0x69,0xB1,100)


text:
(PKEY_Photo_FocalPlaneYResolutionDenominator,0x1D6179A6,0xA876,0x4031,0xB0,0x13,0x33,0x47,0xB2,0xB6,0x4D,0xC8,100)


text:
(PKEY_Photo_FocalPlaneYResolutionNumerator,0xA2E541C5,0x4440,0x4BA8,0x86,0x7E,0x75,0xCF,0xC0,0x68,0x28,0xCD,100)


text:
(PKEY_Photo_GainControlDenominator,0x42864DFD,0x9DA4,0x4F77,0xBD,0xED,0x4A,0xAD,0x7B,0x25,0x67,0x35,100)


text:
(PKEY_Photo_GainControlNumerator,0x8E8ECF7C,0xB7B8,0x4EB8,0xA6,0x3F,0x0E,0xE7,0x15,0xC9,0x6F,0x9E,100)


text:
(PKEY_Photo_MaxApertureDenominator,0xC77724D4,0x601F,0x46C5,0x9B,0x89,0xC5,0x3F,0x93,0xBC,0xEB,0x77,100)


text:
(PKEY_Photo_MaxApertureNumerator,0xC107E191,0xA459,0x44C5,0x9A,0xE6,0xB9,0x52,0xAD,0x4B,0x90,0x6D,100)


text:
(PKEY_Photo_PhotometricInterpretation,0x341796F1,0x1DF9,0x4B1C,0xA5,0x64,0x91,0xBD,0xEF,0xA4,0x38,0x77,100)


text:
(PKEY_Photo_PhotometricInterpretationText,0x821437D6,0x9EAB,0x4765,0xA5,0x89,0x3B,0x1C,0xBB,0xD2,0x2A,0x61,100)


text:
(PKEY_Photo_ShutterSpeedDenominator,0xE13D8975,0x81C7,0x4948,0xAE,0x3F,0x37,0xCA,0xE1,0x1E,0x8F,0xF7,100)


text:
(PKEY_Photo_ShutterSpeedNumerator,0x16EA4042,0xD6F4,0x4BCA,0x83,0x49,0x7C,0x78,0xD3,0x0F,0xB3,0x33,100)


text:
(PKEY_Photo_SubjectDistanceDenominator,0x0C840A88,0xB043,0x466D,0x97,0x66,0xD4,0xB2,0x6D,0xA3,0xFA,0x77,100)


text:
(PKEY_Photo_SubjectDistanceNumerator,0x8AF4961C,0xF526,0x43E5,0xAA,0x81,0xDB,0x76,0x82,0x19,0x17,0x8D,100)


text:
(PKEY_PropList_ContentViewModeForBrowse,0xC9944A21,0xA406,0x48FE,0x82,0x25,0xAE,0xC7,0xE2,0x4C,0x21,0x1B,13)


text:
(PKEY_PropList_ContentViewModeForSearch,0xC9944A21,0xA406,0x48FE,0x82,0x25,0xAE,0xC7,0xE2,0x4C,0x21,0x1B,14)


text:
(PKEY_PropList_FileOperationPrompt,0xC9944A21,0xA406,0x48FE,0x82,0x25,0xAE,0xC7,0xE2,0x4C,0x21,0x1B,10)


text:
(PKEY_RecordedTV_DateContentExpires,0x6D748DE2,0x8D38,0x4CC3,0xAC,0x60,0xF0,0x09,0xB0,0x57,0xC5,0x57,15)


text:
(PKEY_RecordedTV_IsClosedCaptioningAvailable,0x6D748DE2,0x8D38,0x4CC3,0xAC,0x60,0xF0,0x09,0xB0,0x57,0xC5,0x57,12)


text:
(PKEY_RecordedTV_IsRepeatBroadcast,0x6D748DE2,0x8D38,0x4CC3,0xAC,0x60,0xF0,0x09,0xB0,0x57,0xC5,0x57,13)


text:
(PKEY_RecordedTV_NetworkAffiliation,0x2C53C813,0xFB63,0x4E22,0xA1,0xAB,0x0B,0x33,0x1C,0xA1,0xE2,0x73,100)


text:
(PKEY_RecordedTV_OriginalBroadcastDate,0x4684FE97,0x8765,0x4842,0x9C,0x13,0xF0,0x06,0x44,0x7B,0x17,0x8C,100)


text:
(PKEY_RecordedTV_ProgramDescription,0x6D748DE2,0x8D38,0x4CC3,0xAC,0x60,0xF0,0x09,0xB0,0x57,0xC5,0x57,3)


text:
(PKEY_RecordedTV_RecordingTime,0xA5477F61,0x7A82,0x4ECA,0x9D,0xDE,0x98,0xB6,0x9B,0x24,0x79,0xB3,100)


text:
(PKEY_RecordedTV_StationCallSign,0x6D748DE2,0x8D38,0x4CC3,0xAC,0x60,0xF0,0x09,0xB0,0x57,0xC5,0x57,5)


text:
(PKEY_Search_ExtendedProperties,0x7B03B546,0xFA4F,0x4A52,0xA2,0xFE,0x03,0xD5,0x31,0x1E,0x58,0x65,100)


text:
(PKEY_Search_QueryFocusedSummary,0x560C36C0,0x503A,0x11CF,0xBA,0xA1,0x00,0x00,0x4C,0x75,0x2A,0x9A,3)


text:
(PKEY_Search_QueryFocusedSummaryWithFallback,0x560C36C0,0x503A,0x11CF,0xBA,0xA1,0x00,0x00,0x4C,0x75,0x2A,0x9A,4)


text:
(PKEY_Search_UrlToIndexWithModificationTime,0x0B63E343,0x9CCC,0x11D0,0xBC,0xDB,0x00,0x80,0x5F,0xCC,0xCE,0x04,12)


text:
(PKEY_Link_TargetSFGAOFlagsStrings,0xD6942081,0xD53B,0x443D,0xAD,0x47,0x5E,0x05,0x9D,0x9C,0xD2,0x7A,3)


text:
(PKEY_AppUserModel_ExcludeFromShowInNewInstall,0x9F4C2855,0x9F79,0x4B39,0xA8,0xD0,0xE1,0xD4,0x2D,0xE1,0xD5,0xF3,8)


text:
(PKEY_AppUserModel_IsDestListSeparator,0x9F4C2855,0x9F79,0x4B39,0xA8,0xD0,0xE1,0xD4,0x2D,0xE1,0xD5,0xF3,6)


text:
(PKEY_AppUserModel_PreventPinning,0x9F4C2855,0x9F79,0x4B39,0xA8,0xD0,0xE1,0xD4,0x2D,0xE1,0xD5,0xF3,9)


text:
(PKEY_AppUserModel_RelaunchCommand,0x9F4C2855,0x9F79,0x4B39,0xA8,0xD0,0xE1,0xD4,0x2D,0xE1,0xD5,0xF3,2)


text:
(PKEY_AppUserModel_RelaunchDisplayNameResource,0x9F4C2855,0x9F79,0x4B39,0xA8,0xD0,0xE1,0xD4,0x2D,0xE1,0xD5,0xF3,4)


text:
(PKEY_AppUserModel_RelaunchIconResource,0x9F4C2855,0x9F79,0x4B39,0xA8,0xD0,0xE1,0xD4,0x2D,0xE1,0xD5,0xF3,3)


text:
(PKEY_Sync_ConflictFirstLocation,0xCE50C159,0x2FB8,0x41FD,0xBE,0x68,0xD3,0xE0,0x42,0xE2,0x74,0xBC,6)


text:
(PKEY_Sync_ConflictSecondLocation,0xCE50C159,0x2FB8,0x41FD,0xBE,0x68,0xD3,0xE0,0x42,0xE2,0x74,0xBC,7)


text:
(PKEY_Video_HorizontalAspectRatio,0x64440491,0x4C8B,0x11D1,0x8B,0x70,0x08,0x00,0x36,0xB1,0x1A,0x03,42)


text:
(PKEY_Video_VerticalAspectRatio,0x64440491,0x4C8B,0x11D1,0x8B,0x70,0x08,0x00,0x36,0xB1,0x1A,0x03,45)


text:
(PKEY_AudioEndpoint_ControlPanelPageProvider,0x1da5d803,0xd492,0x4edd,0x8c,0x23,0xe0,0xc0,0xff,0xee,0x7f,0x0e,1)


text:
(PKEY_AudioEndpoint_PhysicalSpeakers,0x1da5d803,0xd492,0x4edd,0x8c,0x23,0xe0,0xc0,0xff,0xee,0x7f,0x0e,3)


text:
(PKEY_AudioEndpoint_Disable_SysFx,0x1da5d803,0xd492,0x4edd,0x8c,0x23,0xe0,0xc0,0xff,0xee,0x7f,0x0e,5)


text:
(PKEY_AudioEndpoint_FullRangeSpeakers,0x1da5d803,0xd492,0x4edd,0x8c,0x23,0xe0,0xc0,0xff,0xee,0x7f,0x0e,6)


text:
(PKEY_AudioEndpoint_Supports_EventDriven_Mode,0x1da5d803,0xd492,0x4edd,0x8c,0x23,0xe0,0xc0,0xff,0xee,0x7f,0x0e,7)


text:
( (This)->lpVtbl -> OnChannelVolumeChanged(This,ChannelCount,NewChannelVolumeArray,ChangedChannel,EventContext) )


text:
( (This)->lpVtbl -> GetVolumeRangeChannel(This,iChannel,pflVolumeMindB,pflVolumeMaxdB,pflVolumeIncrementdB) )


text:
(PKEY_Device_UINumberDescFormat,0xa45c254e,0xdf1c,0x4efd,0x80,0x20,0x67,0xd1,0x46,0xa8,0x50,0xe0,31)


text:
(PKEY_Device_RemovalPolicyDefault,0xa45c254e,0xdf1c,0x4efd,0x80,0x20,0x67,0xd1,0x46,0xa8,0x50,0xe0,34)


text:
(PKEY_Device_RemovalPolicyOverride,0xa45c254e,0xdf1c,0x4efd,0x80,0x20,0x67,0xd1,0x46,0xa8,0x50,0xe0,35)


text:
(PKEY_Device_TransportRelations,0x4340a6c5,0x93fa,0x4706,0x97,0x2c,0x7b,0x64,0x80,0x08,0xa5,0xa7,11)


text:
(PKEY_Device_FriendlyNameAttributes,0x80d81ea6,0x7473,0x4b0c,0x82,0x16,0xef,0xc1,0x1a,0x2c,0x4c,0x8b,3)


text:
(PKEY_Device_ManufacturerAttributes,0x80d81ea6,0x7473,0x4b0c,0x82,0x16,0xef,0xc1,0x1a,0x2c,0x4c,0x8b,4)


text:
(PKEY_Device_PresenceNotForDevice,0x80d81ea6,0x7473,0x4b0c,0x82,0x16,0xef,0xc1,0x1a,0x2c,0x4c,0x8b,5)


text:
(PKEY_Device_DHP_Rebalance_Policy,0x540b947e,0x8b40,0x45bc,0xa8,0xa2,0x6a,0x0b,0x89,0x4c,0xbd,0xa2,2)


text:
(PKEY_Device_BusReportedDeviceDesc,0x540b947e,0x8b40,0x45bc,0xa8,0xa2,0x6a,0x0b,0x89,0x4c,0xbd,0xa2,4)


text:
(PKEY_Device_DriverPropPageProvider,0xa8b865dd,0x2e3d,0x4094,0xad,0x97,0xe5,0x93,0xa7,0xc,0x75,0xd6,10)


text:
(PKEY_Device_ResourcePickerExceptions,0xa8b865dd,0x2e3d,0x4094,0xad,0x97,0xe5,0x93,0xa7,0xc,0x75,0xd6,13)


text:
(PKEY_Device_GenericDriverInstalled,0xa8b865dd,0x2e3d,0x4094,0xad,0x97,0xe5,0x93,0xa7,0xc,0x75,0xd6,18)


text:
(PKEY_Device_AdditionalSoftwareRequested,0xa8b865dd,0x2e3d,0x4094,0xad,0x97,0xe5,0x93,0xa7,0xc,0x75,0xd6,19)


text:
(PKEY_Device_SafeRemovalRequired,0xafd97640,0x86a3,0x4210,0xb6,0x7c,0x28,0x9c,0x41,0xaa,0xbe,0x55,2)


text:
(PKEY_Device_SafeRemovalRequiredOverride,0xafd97640,0x86a3,0x4210,0xb6,0x7c,0x28,0x9c,0x41,0xaa,0xbe,0x55,3)


text:
(PKEY_DrvPkg_DetailedDescription,0xcf73bb51,0x3abf,0x44a2,0x85,0xe0,0x9a,0x3d,0xc7,0xa1,0x21,0x32,4)


text:
(PKEY_DeviceClass_Characteristics,0x4321918b,0xf69e,0x470d,0xa5,0xde,0x4d,0x88,0xc7,0x5a,0xd2,0x4b,29)


text:
(PKEY_DeviceClass_PropPageProvider,0x259abffc,0x50a7,0x47ce,0xaf,0x8,0x68,0xc9,0xa7,0xd7,0x33,0x66,6)


text:
(PKEY_DeviceClass_DefaultService,0x259abffc,0x50a7,0x47ce,0xaf,0x8,0x68,0xc9,0xa7,0xd7,0x33,0x66,11)


text:
(PKEY_DeviceClass_ClassCoInstallers,0x713d1703,0xa2e2,0x49f5,0x92,0x14,0x56,0x47,0x2e,0xf3,0xda,0x5c,2)


text:
(PKEY_DeviceInterface_FriendlyName,0x026e516e,0xb814,0x414b,0x83,0xcd,0x85,0x6d,0x6f,0xef,0x48,0x22,2)


text:
(PKEY_DeviceInterfaceClass_DefaultInterface,0x14c83a99,0x0b3f,0x44b7,0xbe,0x4c,0xa1,0x78,0xd3,0x99,0x05,0x64,2)


text:
( (This)->lpVtbl -> Initialize(This,ShareMode,StreamFlags,hnsBufferDuration,hnsPeriodicity,pFormat,AudioSessionGuid) )


text:
( (This)->lpVtbl -> GetBuffer(This,ppData,pNumFramesToRead,pdwFlags,pu64DevicePosition,pu64QPCPosition) )


text:
const AFX_DISPMAP* PASCAL theClass::GetThisDispatchMap() { return &theClass::dispatchMap; } const AFX_DISPMAP* theClass::GetDispatchMap() const { return &theClass::dispatchMap; } AFX_COMDAT const AFX_DISPMAP theClass::dispatchMap = { &baseClass::GetThisDispatchMap, &theClass::_dispatchEntries[0], &theClass::_dispatchEntryCount, &theClass::_dwStockPropMask }; AFX_COMDAT UINT theClass::_dispatchEntryCount = (UINT)-1; AFX_COMDAT DWORD theClass::_dwStockPropMask = (DWORD)-1; AFX_COMDAT const AFX_DISPMAP_ENTRY theClass::_dispatchEntries[] = {


text:
const AFX_DISPMAP* theClass::GetDispatchMap() const { return &theClass::dispatchMap; } AFX_COMDAT const AFX_DISPMAP theClass::dispatchMap = { &baseClass::dispatchMap, &theClass::_dispatchEntries[0], &theClass::_dispatchEntryCount, &theClass::_dwStockPropMask }; AFX_COMDAT UINT theClass::_dispatchEntryCount = (UINT)-1; AFX_COMDAT DWORD theClass::_dwStockPropMask = (DWORD)-1; AFX_COMDAT const AFX_DISPMAP_ENTRY theClass::_dispatchEntries[] = {


text:
{ VTS_NONE, DISPID_UNKNOWN, VTS_NONE, VT_VOID, (AFX_PMSG)NULL, (AFX_PMSG)NULL, (size_t)-1, afxDispCustom } };


text:
{ _T(szExternalName), DISPID_UNKNOWN, vtsParams, vtRetVal, (AFX_PMSG)(void (theClass::*)(void))&pfnMember, (AFX_PMSG)0, 0, afxDispCustom },


text:
{ _T(szExternalName), DISPID_UNKNOWN, NULL, vtPropType, (AFX_PMSG)0, (AFX_PMSG)0, offsetof(theClass, memberName), afxDispCustom },


text:
{ _T(szExternalName), DISPID_UNKNOWN, NULL, vtPropType, (AFX_PMSG)0, (AFX_PMSG)(void (theClass::*)(void))&pfnAfterSet, offsetof(theClass, memberName), afxDispCustom },


text:
{ _T(szExternalName), DISPID_UNKNOWN, NULL, vtPropType, (AFX_PMSG)(void (theClass::*)(void))&pfnGet, (AFX_PMSG)(void (theClass::*)(void))&pfnSet, 0, afxDispCustom },


text:
{ _T(szExternalName), DISPID_UNKNOWN, vtsParams, vtPropType, (AFX_PMSG)(void (theClass::*)(void))&pfnGet, (AFX_PMSG)(void (theClass::*)(void))&pfnSet, 0, afxDispCustom },


text:
{ _T(szExternalName), dispid, vtsParams, vtRetVal, (AFX_PMSG)(void (theClass::*)(void))&pfnMember, (AFX_PMSG)0, 0, afxDispCustom },


text:
{ _T(szExternalName), dispid, NULL, vtPropType, (AFX_PMSG)0, (AFX_PMSG)0, offsetof(theClass, memberName), afxDispCustom },


text:
{ _T(szExternalName), dispid, NULL, vtPropType, (AFX_PMSG)0, (AFX_PMSG)(void (theClass::*)(void))&pfnAfterSet, offsetof(theClass, memberName), afxDispCustom },


text:
{ _T(szExternalName), dispid, NULL, vtPropType, (AFX_PMSG)(void (theClass::*)(void))&pfnGet, (AFX_PMSG)(void (theClass::*)(void))&pfnSet, 0, afxDispCustom },


text:
{ _T(szExternalName), dispid, vtsParams, vtPropType, (AFX_PMSG)(void (theClass::*)(void))&pfnGet, (AFX_PMSG)(void (theClass::*)(void))&pfnSet, 0, afxDispCustom },


text:
{ _T(szExternalName), DISPID_UNKNOWN, NULL, VT_MFCVALUE, (AFX_PMSG)0, (AFX_PMSG)0, 0, afxDispCustom },


text:
COleObjectFactory class_name::factory(class_name::guid, RUNTIME_CLASS(class_name), FALSE, _T(external_name)); AFX_COMDAT const GUID class_name::guid = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } };


text:
COleObjectFactory class_name::factory(class_name::guid, RUNTIME_CLASS(class_name), FALSE, nFlags, _T(external_name)); AFX_COMDAT const GUID class_name::guid = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } };


text:
class X##localClass : public CConnectionPoint { public: X##localClass() { m_nOffset = offsetof(theClass, m_x##localClass); }


text:
const AFX_CONNECTIONMAP* PASCAL theClass::GetThisConnectionMap() { return &theClass::connectionMap; } const AFX_CONNECTIONMAP* theClass::GetConnectionMap() const { return &theClass::connectionMap; } AFX_COMDAT const AFX_CONNECTIONMAP theClass::connectionMap = { &theBase::GetThisConnectionMap, &theClass::_connectionEntries[0], }; AFX_COMDAT const AFX_CONNECTIONMAP_ENTRY theClass::_connectionEntries[] = {


text:
const AFX_CONNECTIONMAP* theClass::GetConnectionMap() const { return &theClass::connectionMap; } AFX_COMDAT const AFX_CONNECTIONMAP theClass::connectionMap = { &(theBase::connectionMap), &theClass::_connectionEntries[0], }; AFX_COMDAT const AFX_CONNECTIONMAP_ENTRY theClass::_connectionEntries[] = {


text:
PTM_WARNING_DISABLE const AFX_EVENTSINKMAP* PASCAL theClass::GetThisEventSinkMap() { return &theClass::eventsinkMap; } const AFX_EVENTSINKMAP* theClass::GetEventSinkMap() const { return &theClass::eventsinkMap; } AFX_COMDAT const AFX_EVENTSINKMAP theClass::eventsinkMap = { &baseClass::GetThisEventSinkMap, &theClass::_eventsinkEntries[0], &theClass::_eventsinkEntryCount }; AFX_COMDAT UINT theClass::_eventsinkEntryCount = (UINT)-1; AFX_COMDAT const AFX_EVENTSINKMAP_ENTRY theClass::_eventsinkEntries[] = {


text:
PTM_WARNING_DISABLE const AFX_EVENTSINKMAP* theClass::GetEventSinkMap() const { return &theClass::eventsinkMap; } AFX_COMDAT const AFX_EVENTSINKMAP theClass::eventsinkMap = { &baseClass::eventsinkMap, &theClass::_eventsinkEntries[0], &theClass::_eventsinkEntryCount }; AFX_COMDAT UINT theClass::_eventsinkEntryCount = (UINT)-1; AFX_COMDAT const AFX_EVENTSINKMAP_ENTRY theClass::_eventsinkEntries[] = {


text:
PTM_WARNING_RESTORE { VTS_NONE, DISPID_UNKNOWN, VTS_NONE, VT_VOID, (AFX_PMSG)NULL, (AFX_PMSG)NULL, (size_t)-1, afxDispCustom, (UINT)-1, 0 } };


text:
{ _T(""), dispid, vtsParams, VT_BOOL, (AFX_PMSG)(void (theClass::*)(void))&pfnHandler, (AFX_PMSG)0, 0, afxDispCustom, id, (UINT)-1 },


text:
{ _T(""), dispid, vtsParams, VT_BOOL, (AFX_PMSG)(void (theClass::*)(void))&pfnHandler, (AFX_PMSG)0, 0, afxDispCustom, idFirst, idLast },


text:
{ _T(""), dispid, VTS_NONE, VT_VOID, (AFX_PMSG)(BOOL (CCmdTarget::*)(BOOL*))&pfnRequest, (AFX_PMSG)(BOOL (CCmdTarget::*)(void))&pfnChanged, 1, afxDispCustom, id, (UINT)-1 },


text:
{ _T(""), dispid, VTS_NONE, VT_VOID, (AFX_PMSG)(BOOL (CCmdTarget::*)(UINT, BOOL*))&pfnRequest, (AFX_PMSG)(BOOL (CCmdTarget::*)(UINT))&pfnChanged, 1, afxDispCustom, idFirst, idLast },


text:
{ _T(""), DISPID_UNKNOWN, VTS_NONE, VT_VOID, (AFX_PMSG)(BOOL (CCmdTarget::*)(DSCSTATE, DSCREASON, BOOL*))&pfnNotify, (AFX_PMSG)0, 1, afxDispCustom, id, (UINT)-1 },


text:
{ _T(""), DISPID_UNKNOWN, VTS_NONE, VT_VOID, (AFX_PMSG)(BOOL (CCmdTarget::*)(UINT, DSCSTATE, DSCREASON, BOOL*))&pfnNotify, (AFX_PMSG)0, 1, afxDispCustom, idFirst, idLast },


text:
{ _T(""), dispid, vtsParams, VT_BOOL, (AFX_PMSG)(void (theClass::*)(void))&pfnHandler, (AFX_PMSG)0, 0, afxDispCustom, (UINT)-1, (UINT)-1 },


text:
{ _T(""), dispid, VTS_NONE, VT_VOID, (AFX_PMSG)(BOOL (CCmdTarget::*)(BOOL*))&pfnRequest, (AFX_PMSG)(BOOL (CCmdTarget::*)(void))&pfnChanged, 1, afxDispCustom, (UINT)-1, (UINT)-1 },


text:
PTM_WARNING_DISABLE __declspec(selectany) const AFX_EVENTSINKMAP theClass::eventsinkMap = { &baseClass::GetThisEventSinkMap, &theClass::_eventsinkEntries[0], &theClass::_eventsinkEntryCount }; __declspec(selectany) UINT theClass::_eventsinkEntryCount = (UINT)-1; __declspec(selectany) const AFX_EVENTSINKMAP_ENTRY theClass::_eventsinkEntries[] = {


text:
PTM_WARNING_DISABLE __declspec(selectany) const AFX_EVENTSINKMAP theClass::eventsinkMap = { &baseClass::eventsinkMap, &theClass::_eventsinkEntries[0], &theClass::_eventsinkEntryCount }; __declspec(selectany) UINT theClass::_eventsinkEntryCount = (UINT)-1; __declspec(selectany) const AFX_EVENTSINKMAP_ENTRY theClass::_eventsinkEntries[] = {


text:
protected: virtual UINT GetTypeInfoCount(); virtual HRESULT GetTypeLib(LCID, LPTYPELIB*); virtual CTypeLibCache* GetTypeLibCache();


text:
UINT class_name::GetTypeInfoCount() { return 1; } HRESULT class_name::GetTypeLib(LCID lcid, LPTYPELIB* ppTypeLib) { return ::LoadRegTypeLib(tlid, wVerMajor, wVerMinor, lcid, ppTypeLib); } CTypeLibCache* class_name::GetTypeLibCache() { AFX_MANAGE_STATE(m_pModuleState); return AfxGetTypeLibCache(&tlid); }


text:
do { bool __afx_condVal=!!(cond); ASSERT(__afx_condVal); _Analysis_assume_(__afx_condVal); } while(0)


text:
do { int __afx_condVal=!!(cond); ASSERT(__afx_condVal); if (!(__afx_condVal)){exception;} } while (false)


text:
do { TCHAR szErrorMessage[512]; if (pException->GetErrorMessage(szErrorMessage, sizeof(szErrorMessage)/sizeof(*szErrorMessage), 0)) TRACE(traceAppMsg, 0, _T("%Ts (%Ts:%d)\n%Ts\n"), szMsg, _T(__FILE__), __LINE__, szErrorMessage); else TRACE(traceAppMsg, 0, _T("%Ts (%Ts:%d)\n"), szMsg, _T(__FILE__), __LINE__); ASSERT(FALSE); } while (0)


text:
do { CString strMsg; TCHAR szErrorMessage[512]; if (pException->GetErrorMessage(szErrorMessage, sizeof(szErrorMessage)/sizeof(*szErrorMessage), 0)) strMsg.Format(_T("%Ts (%Ts:%d)\n%Ts"), szMsg, _T(__FILE__), __LINE__, szErrorMessage); else strMsg.Format(_T("%Ts (%Ts:%d)"), szMsg, _T(__FILE__), __LINE__); AfxMessageBox(strMsg); } while (0)


text:
do { REPORT_EXCEPTION((pException), _T("Exception thrown in destructor")); delete pException; } while (0)


text:
protected: static CRuntimeClass* PASCAL _GetBaseClass(); public: static const CRuntimeClass class##class_name; static CRuntimeClass* PASCAL GetThisClass(); virtual CRuntimeClass* GetRuntimeClass() const;


text:
protected: static CRuntimeClass* PASCAL _GetBaseClass(); public: static CRuntimeClass class##class_name; static CRuntimeClass* PASCAL GetThisClass(); virtual CRuntimeClass* GetRuntimeClass() const;


text:
public: static const CRuntimeClass class##class_name; virtual CRuntimeClass* GetRuntimeClass() const;


text:
_DECLARE_DYNCREATE(class_name) AFX_API friend CArchive& AFXAPI operator>>(CArchive& ar, class_name* &pOb);


text:
CRuntimeClass* PASCAL class_name::_GetBaseClass() { return RUNTIME_CLASS(base_class_name); } AFX_COMDAT const CRuntimeClass class_name::class##class_name = { #class_name, sizeof(class class_name), wSchema, pfnNew, &class_name::_GetBaseClass, NULL, class_init }; CRuntimeClass* PASCAL class_name::GetThisClass() { return _RUNTIME_CLASS(class_name); } CRuntimeClass* class_name::GetRuntimeClass() const { return _RUNTIME_CLASS(class_name); }


text:
CRuntimeClass* PASCAL class_name::_GetBaseClass() { return RUNTIME_CLASS(base_class_name); } AFX_COMDAT CRuntimeClass class_name::class##class_name = { #class_name, sizeof(class class_name), wSchema, pfnNew, &class_name::_GetBaseClass, NULL, class_init }; CRuntimeClass* PASCAL class_name::GetThisClass() { return _RUNTIME_CLASS(class_name); } CRuntimeClass* class_name::GetRuntimeClass() const { return _RUNTIME_CLASS(class_name); }


text:
AFX_COMDAT const CRuntimeClass class_name::class##class_name = { #class_name, sizeof(class class_name), wSchema, pfnNew, RUNTIME_CLASS(base_class_name), NULL, class_init }; CRuntimeClass* class_name::GetRuntimeClass() const { return RUNTIME_CLASS(class_name); }


text:
AFX_COMDAT CRuntimeClass class_name::class##class_name = { #class_name, sizeof(class class_name), wSchema, pfnNew, RUNTIME_CLASS(base_class_name), NULL, class_init }; CRuntimeClass* class_name::GetRuntimeClass() const { return RUNTIME_CLASS(class_name); }


text:
CObject* PASCAL class_name::CreateObject() { return new class_name; } IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, class_name::CreateObject, NULL)


text:
CObject* PASCAL class_name::CreateObject() { return new class_name; } extern AFX_CLASSINIT _init_##class_name; _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, class_name::CreateObject, &_init_##class_name) AFX_CLASSINIT _init_##class_name(RUNTIME_CLASS(class_name)); CArchive& AFXAPI operator>>(CArchive& ar, class_name* &pOb) { pOb = (class_name*) ar.ReadObject(RUNTIME_CLASS(class_name)); return ar; }


text:
} catch (CException* e) { { ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); _afxExceptionLink.m_pException = e;


text:
} catch (CException* e) { ASSERT(e->IsKindOf(RUNTIME_CLASS(CException))); _afxExceptionLink.m_pException = e; } }


text:
typedef interface iface { const struct iface##Vtbl FAR* lpVtbl; } iface; typedef const struct iface##Vtbl iface##Vtbl; const struct iface##Vtbl


text:
typedef interface iface { struct iface##Vtbl FAR* lpVtbl; } iface; typedef struct iface##Vtbl iface##Vtbl; struct iface##Vtbl


text:
(((int)((LPBYTE)(&((structname*)0)->member) - ((LPBYTE)((structname*)0)))) + sizeof(((structname*)0)->member))


text:
( (This)->lpVtbl -> CreateViewWindow3(This,psbOwner,psvPrev,dwViewFlags,dwMask,dwFlags,fvMode,pvid,prcView,phwndView) )


text:
( (This)->lpVtbl -> UpdateProgress(This,ullSizeCurrent,ullSizeTotal,nFilesCurrent,nFilesTotal,nFoldersCurrent,nFoldersTotal) )


text:
( (This)->lpVtbl -> CreateItem(This,pszName,dwAttributes,ullSize,flags,riidItem,ppvItem,riidResources,ppvResources) )


text:
( (This)->lpVtbl -> PostMoveItem(This,dwFlags,psiItem,psiDestinationFolder,pszNewName,hrMove,psiNewlyCreated) )


text:
( (This)->lpVtbl -> PostCopyItem(This,dwFlags,psiItem,psiDestinationFolder,pszNewName,hrCopy,psiNewlyCreated) )


text:
( (This)->lpVtbl -> PostNewItem(This,dwFlags,psiDestinationFolder,pszNewName,pszTemplateName,dwFileAttributes,hrNew,psiNewItem) )


text:
( (This)->lpVtbl -> HandleEventWithContent(This,pszDeviceID,pszAltDeviceID,pszEventType,pszContentTypeHandler,pdataobject) )


text:
( (This)->lpVtbl -> GetLocation(This,pszPathBuffer,cch,pdwPriority,prgSize,dwRecClrDepth,pdwFlags) )


text:
( (This)->lpVtbl -> UpdateProgress(This,ullPointsCurrent,ullPointsTotal,ullSizeCurrent,ullSizeTotal,ullItemsCurrent,ullItemsTotal) )


text:
( (This)->lpVtbl -> NewItem(This,psiDestinationFolder,dwFileAttributes,pszName,pszTemplateName,pfopsItem) )


text:
( (This)->lpVtbl -> QueryAppIsDefault(This,pszQuery,atQueryType,alQueryLevel,pszAppRegistryName,pfDefault) )


text:
( (This)->lpVtbl -> EvaluateNewWindow(This,pszUrl,pszName,pszUrlContext,pszFeatures,fReplace,dwFlags,dwUserActionTime) )


text:
( (This)->lpVtbl -> GetThumbnail(This,pShellItem,cxyRequestedThumbSize,flags,ppvThumb,pOutFlags,pThumbnailID) )


text:
do { u_int __i; for (__i = 0; __i < ((fd_set FAR *)(set))->fd_count ; __i++) { if (((fd_set FAR *)(set))->fd_array[__i] == fd) { while (__i < ((fd_set FAR *)(set))->fd_count-1) { ((fd_set FAR *)(set))->fd_array[__i] = ((fd_set FAR *)(set))->fd_array[__i+1]; __i++; } ((fd_set FAR *)(set))->fd_count--; break; } } } while(0)


text:
do { u_int __i; for (__i = 0; __i < ((fd_set FAR *)(set))->fd_count; __i++) { if (((fd_set FAR *)(set))->fd_array[__i] == (fd)) { break; } } if (__i == ((fd_set FAR *)(set))->fd_count) { if (((fd_set FAR *)(set))->fd_count < FD_SETSIZE) { ((fd_set FAR *)(set))->fd_array[__i] = (fd); ((fd_set FAR *)(set))->fd_count++; } } } while(0)


text:
((tvp)->tv_sec cmp (uvp)->tv_sec || (tvp)->tv_sec == (uvp)->tv_sec && (tvp)->tv_usec cmp (uvp)->tv_usec)


text:
{ DWORD _in = (in); (out) = ((_in << 8) & 0x00ff0000) | (_in << 24) | ((_in >> 8) & 0x0000ff00) | (_in >> 24); }


text:
{ PDNS_HEADER _head = (pHeader); INLINE_HTONS(_head->Xid, _head->Xid ); INLINE_HTONS(_head->QuestionCount, _head->QuestionCount ); INLINE_HTONS(_head->AnswerCount, _head->AnswerCount ); INLINE_HTONS(_head->NameServerCount,_head->NameServerCount ); INLINE_HTONS(_head->AdditionalCount,_head->AdditionalCount ); }


text:
{ PDNS_RRSET _prrset = &(rrset); _prrset->pFirstRR = NULL; _prrset->pLastRR = (PDNS_RECORD) &_prrset->pFirstRR; }


text:
{ PDNS_RRSET _prrset = &(rrset); PDNS_RECORD _prrnew = (pnewRR); _prrset->pLastRR->pNext = _prrnew; _prrset->pLastRR = _prrnew; }


text:
( (This)->lpVtbl -> AddTransitionBetweenKeyframes(This,variable,transition,startKeyframe,endKeyframe) )


text:
( (This)->lpVtbl -> CreateSinusoidalTransitionFromRange(This,duration,minimumValue,maximumValue,period,slope,transition) )


text:
( (This)->lpVtbl -> CreateAccelerateDecelerateTransition(This,duration,finalValue,accelerationRatio,decelerationRatio,transition) )


text:
( (This)->lpVtbl -> CreateParabolicTransitionFromAcceleration(This,finalValue,finalVelocity,acceleration,transition) )


text:
( (This)->lpVtbl -> GetDependencies(This,initialValueDependencies,initialVelocityDependencies,durationDependencies) )


text:
{ WM_COMMAND, CN_COMMAND, (WORD)id, (WORD)idLast, AfxSigCmd_RANGE, (AFX_PMSG) (static_cast< void (AFX_MSG_CALL CCmdTarget::*)(UINT) > (memberFxn)) },


text:
{ WM_COMMAND, CN_COMMAND, (WORD)id, (WORD)id, AfxSigCmd_EX, (AFX_PMSG) (static_cast< BOOL (AFX_MSG_CALL CCmdTarget::*)(UINT) > (memberFxn)) },


text:
{ WM_COMMAND, CN_COMMAND, (WORD)id, (WORD)idLast, AfxSigCmd_EX, (AFX_PMSG) (static_cast< BOOL (AFX_MSG_CALL CCmdTarget::*)(UINT) > (memberFxn)) },


text:
{ WM_COMMAND, CN_UPDATE_COMMAND_UI, (WORD)id, (WORD)id, AfxSigCmdUI, (AFX_PMSG) (static_cast< void (AFX_MSG_CALL CCmdTarget::*)(CCmdUI*) > (memberFxn)) },


text:
{ WM_COMMAND, CN_UPDATE_COMMAND_UI, (WORD)id, (WORD)idLast, AfxSigCmdUI, (AFX_PMSG) (static_cast< void (AFX_MSG_CALL CCmdTarget::*)(CCmdUI*) > (memberFxn)) },


text:
{ WM_NOTIFY, (WORD)(int)wNotifyCode, (WORD)id, (WORD)id, AfxSigNotify_v, (AFX_PMSG) (static_cast< void (AFX_MSG_CALL CCmdTarget::*)(NMHDR*, LRESULT*) > (memberFxn)) },


text:
{ WM_NOTIFY, (WORD)(int)wNotifyCode, (WORD)id, (WORD)idLast, AfxSigNotify_RANGE, (AFX_PMSG) (static_cast< void (AFX_MSG_CALL CCmdTarget::*)(UINT, NMHDR*, LRESULT*) > (memberFxn)) },


text:
{ WM_NOTIFY, (WORD)(int)wNotifyCode, (WORD)id, (WORD)id, AfxSigNotify_EX, (AFX_PMSG) (static_cast< BOOL (AFX_MSG_CALL CCmdTarget::*)(UINT, NMHDR*, LRESULT*) > (memberFxn)) },


text:
{ WM_NOTIFY, (WORD)(int)wNotifyCode, (WORD)id, (WORD)idLast, AfxSigNotify_EX, (AFX_PMSG) (static_cast< BOOL (AFX_MSG_CALL CCmdTarget::*)(UINT, NMHDR*, LRESULT*) > (memberFxn)) },


text:
{ WM_COMMAND, (WORD)wNotifyCode, (WORD)id, (WORD)id, AfxSigCmd_v, (static_cast< AFX_PMSG > (memberFxn)) },


text:
{ WM_COMMAND, (WORD)wNotifyCode, (WORD)id, (WORD)idLast, AfxSigCmd_RANGE, (AFX_PMSG) (static_cast< void (AFX_MSG_CALL CCmdTarget::*)(UINT) > (memberFxn)) },


text:
{ WM_COMMAND+WM_REFLECT_BASE, (WORD)wNotifyCode, 0, 0, AfxSigCmd_v, (static_cast<AFX_PMSG> (memberFxn)) },


text:
{ WM_COMMAND+WM_REFLECT_BASE, (WORD)wNotifyCode, 0, 0, AfxSigCmd_b, (AFX_PMSG) (static_cast<BOOL (AFX_MSG_CALL CCmdTarget::*)(void)> (memberFxn)) },


text:
{ WM_NOTIFY+WM_REFLECT_BASE, (WORD)(int)wNotifyCode, 0, 0, AfxSigNotify_v, (AFX_PMSG) (static_cast<void (AFX_MSG_CALL CCmdTarget::*)(NMHDR*, LRESULT*) > (memberFxn)) },


text:
{ WM_NOTIFY+WM_REFLECT_BASE, (WORD)(int)wNotifyCode, 0, 0, AfxSigNotify_b, (AFX_PMSG) (static_cast<BOOL (AFX_MSG_CALL CCmdTarget::*)(NMHDR*, LRESULT*) > (memberFxn)) },


text:
{ WM_COMMAND+WM_REFLECT_BASE, (WORD)CN_UPDATE_COMMAND_UI, 0, 0, AfxSigCmdUI, (AFX_PMSG) (static_cast<void (AFX_MSG_CALL CCmdTarget::*)(CCmdUI*) > (memberFxn)) },


text:
{ WM_CREATE, 0, 0, 0, AfxSig_is, (AFX_PMSG) (AFX_PMSGW) (static_cast< int (AFX_MSG_CALL CWnd::*)(LPCREATESTRUCT) > ( &ThisClass :: OnCreate)) },


text:
{ WM_COPYDATA, 0, 0, 0, AfxSig_bWCDS, (AFX_PMSG)(AFX_PMSGW) (static_cast< BOOL (AFX_MSG_CALL CWnd::*)(CWnd*, COPYDATASTRUCT*) > ( &ThisClass :: OnCopyData)) },


text:
{ WM_DESTROY, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnDestroy)) },


text:
{ WM_MOVE, 0, 0, 0, AfxSig_vvii, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(int, int) > ( &ThisClass :: OnMove)) },


text:
{ WM_SIZE, 0, 0, 0, AfxSig_vwii, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, int, int) > ( &ThisClass :: OnSize)) },


text:
{ WM_ACTIVATE, 0, 0, 0, AfxSig_vwWb, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CWnd*, BOOL) > ( &ThisClass :: OnActivate)) },


text:
{ WM_SETFOCUS, 0, 0, 0, AfxSig_vW, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CWnd*) > ( &ThisClass :: OnSetFocus)) },


text:
{ WM_KILLFOCUS, 0, 0, 0, AfxSig_vW, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CWnd*) > ( &ThisClass :: OnKillFocus)) },


text:
{ WM_ENABLE, 0, 0, 0, AfxSig_vb, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(BOOL) > ( &ThisClass :: OnEnable)) },


text:
{ WM_HELP, 0, 0, 0, AfxSig_bHELPINFO, (AFX_PMSG)(AFX_PMSGW) (static_cast< BOOL (AFX_MSG_CALL CWnd::*)(HELPINFO*) > ( &ThisClass :: OnHelpInfo)) },


text:
{ WM_PAINT, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnPaint)) },


text:
{ WM_SYNCPAINT, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnSyncPaint)) },


text:
{ WM_CLOSE, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnClose)) },


text:
{ WM_QUERYENDSESSION, 0, 0, 0, AfxSig_bv, (AFX_PMSG)(AFX_PMSGW) (static_cast< BOOL (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnQueryEndSession)) },


text:
{ WM_QUERYOPEN, 0, 0, 0, AfxSig_bv, (AFX_PMSG)(AFX_PMSGW) (static_cast< BOOL (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnQueryOpen)) },


text:
{ WM_ERASEBKGND, 0, 0, 0, AfxSig_bD, (AFX_PMSG)(AFX_PMSGW) (static_cast< BOOL (AFX_MSG_CALL CWnd::*)(CDC*) > ( &ThisClass :: OnEraseBkgnd)) },


text:
{ WM_PRINTCLIENT, 0, 0, 0, AfxSig_l_D_u, (AFX_PMSG)(AFX_PMSGW) (static_cast< LRESULT (AFX_MSG_CALL CWnd::*)(CDC*, UINT) > ( &ThisClass :: OnPrintClient)) },


text:
{ WM_SYSCOLORCHANGE, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnSysColorChange)) },


text:
{ WM_ENDSESSION, 0, 0, 0, AfxSig_vb, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(BOOL) > ( &ThisClass :: OnEndSession)) },


text:
{ WM_SETTEXT, 0, 0, 0, AfxSig_i_v_S, (AFX_PMSG) (AFX_PMSGW) (static_cast< int (AFX_MSG_CALL CWnd::*)(LPCTSTR) > ( &ThisClass :: OnSetText)) },


text:
{ WM_GETTEXT, 0, 0, 0, AfxSig_i_i_s, (AFX_PMSG) (AFX_PMSGW) (static_cast< int (AFX_MSG_CALL CWnd::*)(int, LPTSTR) > ( &ThisClass :: OnGetText)) },


text:
{ WM_GETTEXTLENGTH, 0, 0, 0, AfxSig_u_v_v, (AFX_PMSG) (AFX_PMSGW) (static_cast< UINT (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnGetTextLength)) },


text:
{ WM_SETFONT, 0, 0, 0, AfxSig_v_F_b, (AFX_PMSG) (AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CFont*, BOOL) > ( &ThisClass :: OnSetFont)) },


text:
{ WM_GETFONT, 0, 0, 0, AfxSig_h_v_v, (AFX_PMSG) (AFX_PMSGW) (static_cast< HFONT (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnGetFont)) },


text:
{ WM_SETICON, 0, 0, 0, AfxSig_h_b_h, (AFX_PMSG) (AFX_PMSGW) (static_cast< HICON (AFX_MSG_CALL CWnd::*)(BOOL, HICON) > ( &ThisClass :: OnSetIcon)) },


text:
{ WM_MDISETMENU, 0, 0, 0, AfxSig_h_h_h, (AFX_PMSG) (AFX_PMSGW) (static_cast< HMENU (AFX_MSG_CALL CWnd::*)(HMENU, HMENU) > ( &ThisClass :: OnMDISetMenu)) },


text:
{ WM_MDIREFRESHMENU, 0, 0, 0, AfxSig_h_v_v, (AFX_PMSG) (AFX_PMSGW) (static_cast< HMENU (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnMDIRefreshMenu)) },


text:
{ WM_MDIDESTROY, 0, 0, 0, AfxSig_v_W_v, (AFX_PMSG) (AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CWnd*) > ( &ThisClass :: OnMDIDestroy)) },


text:
{ WM_MDINEXT, 0, 0, 0, AfxSig_MDINext, (AFX_PMSG) (AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CWnd*, BOOL) > ( &ThisClass :: OnMDINext)) },


text:
{ WM_CUT, 0, 0, 0, AfxSig_v_v_v, (AFX_PMSG) (AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnCut)) },


text:
{ WM_COPY, 0, 0, 0, AfxSig_v_v_v, (AFX_PMSG) (AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnCopy)) },


text:
{ WM_PASTE, 0, 0, 0, AfxSig_v_v_v, (AFX_PMSG) (AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnPaste)) },


text:
{ WM_CLEAR, 0, 0, 0, AfxSig_v_v_v, (AFX_PMSG) (AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnClear)) },


text:
{ WM_DISPLAYCHANGE, 0, 0, 0, AfxSig_v_u_ii, (AFX_PMSG) (AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, int, int) > ( &ThisClass :: OnDisplayChange)) },


text:
{ WM_DDE_INITIATE, 0, 0, 0, AfxSig_v_W_uu, (AFX_PMSG) (AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CWnd*, UINT, UINT) > ( &ThisClass :: OnDDEInitiate)) },


text:
{ WM_DDE_EXECUTE, 0, 0, 0, AfxSig_v_W_h, (AFX_PMSG) (AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CWnd*, HANDLE) > ( &ThisClass :: OnDDEExecute)) },


text:
{ WM_DDE_TERMINATE, 0, 0, 0, AfxSig_v_W_v, (AFX_PMSG) (AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CWnd*) > ( &ThisClass :: OnDDETerminate)) },


text:
{ WM_WTSSESSION_CHANGE, 0, 0, 0, AfxSig_vww, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT) > ( &ThisClass :: OnSessionChange)) },


text:
{ WM_SHOWWINDOW, 0, 0, 0, AfxSig_vbw, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(BOOL, UINT) > ( &ThisClass :: OnShowWindow)) },


text:
{ WM_CTLCOLOR, 0, 0, 0, AfxSig_hDWw, (AFX_PMSG)(AFX_PMSGW) (static_cast< HBRUSH (AFX_MSG_CALL CWnd::*)(CDC*, CWnd*, UINT)> ( &ThisClass :: OnCtlColor)) },


text:
{ WM_CTLCOLOR+WM_REFLECT_BASE, 0, 0, 0, AfxSig_hDw, (AFX_PMSG)(AFX_PMSGW) (static_cast< HBRUSH (AFX_MSG_CALL CWnd::*)(CDC*, UINT) > ( &ThisClass :: CtlColor)) },


text:
{ WM_SETTINGCHANGE, 0, 0, 0, AfxSig_vws, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, LPCTSTR) > ( &ThisClass :: OnSettingChange)) },


text:
{ WM_WININICHANGE, 0, 0, 0, AfxSig_vs, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(LPCTSTR) > ( &ThisClass :: OnWinIniChange)) },


text:
{ WM_DEVMODECHANGE, 0, 0, 0, AfxSig_vs, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(LPTSTR) > ( &ThisClass :: OnDevModeChange)) },


text:
{ WM_ACTIVATEAPP, 0, 0, 0, AfxSig_vww, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(BOOL, DWORD) > ( &ThisClass :: OnActivateApp)) },


text:
{ WM_FONTCHANGE, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnFontChange)) },


text:
{ WM_TIMECHANGE, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnTimeChange)) },


text:
{ WM_CANCELMODE, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnCancelMode)) },


text:
{ WM_SETCURSOR, 0, 0, 0, AfxSig_bWww, (AFX_PMSG)(AFX_PMSGW) (static_cast< BOOL (AFX_MSG_CALL CWnd::*)(CWnd*, UINT, UINT) > ( &ThisClass :: OnSetCursor)) },


text:
{ WM_MOUSEACTIVATE, 0, 0, 0, AfxSig_iWww, (AFX_PMSG)(AFX_PMSGW) (static_cast< int (AFX_MSG_CALL CWnd::*)(CWnd*, UINT, UINT) > ( &ThisClass :: OnMouseActivate)) },


text:
{ WM_CHILDACTIVATE, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnChildActivate)) },


text:
{ WM_GETMINMAXINFO, 0, 0, 0, AfxSig_vs, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(MINMAXINFO*) > ( &ThisClass :: OnGetMinMaxInfo)) },


text:
{ WM_ICONERASEBKGND, 0, 0, 0, AfxSig_vD, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CDC*) > ( &ThisClass :: OnIconEraseBkgnd)) },


text:
{ WM_SPOOLERSTATUS, 0, 0, 0, AfxSig_vww, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT) > ( &ThisClass :: OnSpoolerStatus)) },


text:
{ WM_DRAWITEM, 0, 0, 0, AfxSig_vOWNER, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(int, LPDRAWITEMSTRUCT) > ( &ThisClass :: OnDrawItem)) },


text:
{ WM_DRAWITEM+WM_REFLECT_BASE, 0, 0, 0, AfxSig_vs, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(LPDRAWITEMSTRUCT) > ( &ThisClass :: DrawItem)) },


text:
{ WM_MEASUREITEM, 0, 0, 0, AfxSig_vOWNER, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(int, LPMEASUREITEMSTRUCT) > ( &ThisClass :: OnMeasureItem)) },


text:
{ WM_MEASUREITEM+WM_REFLECT_BASE, 0, 0, 0, AfxSig_vs, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(LPMEASUREITEMSTRUCT) > ( &ThisClass :: MeasureItem)) },


text:
{ WM_DELETEITEM, 0, 0, 0, AfxSig_vOWNER, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(int, LPDELETEITEMSTRUCT) > ( &ThisClass :: OnDeleteItem)) },


text:
{ WM_DELETEITEM+WM_REFLECT_BASE, 0, 0, 0, AfxSig_vs, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(LPDELETEITEMSTRUCT) > ( &ThisClass :: DeleteItem)) },


text:
{ WM_CHARTOITEM, 0, 0, 0, AfxSig_iwWw, (AFX_PMSG)(AFX_PMSGW) (static_cast< int (AFX_MSG_CALL CWnd::*)(UINT, CListBox*, UINT) > ( &ThisClass :: OnCharToItem)) },


text:
{ WM_CHARTOITEM+WM_REFLECT_BASE, 0, 0, 0, AfxSig_iww, (AFX_PMSG)(AFX_PMSGW) (static_cast< int (AFX_MSG_CALL CWnd::*)(UINT, UINT) > ( &ThisClass :: CharToItem)) },


text:
{ WM_VKEYTOITEM, 0, 0, 0, AfxSig_iwWw, (AFX_PMSG)(AFX_PMSGW) (static_cast< int (AFX_MSG_CALL CWnd::*)(UINT, CListBox*, UINT) > ( &ThisClass :: OnVKeyToItem)) },


text:
{ WM_VKEYTOITEM+WM_REFLECT_BASE, 0, 0, 0, AfxSig_iww, (AFX_PMSG)(AFX_PMSGW) (static_cast< int (AFX_MSG_CALL CWnd::*)(UINT, UINT) > ( &ThisClass :: VKeyToItem)) },


text:
{ WM_QUERYDRAGICON, 0, 0, 0, AfxSig_hv, (AFX_PMSG)(AFX_PMSGW) (static_cast< HCURSOR (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnQueryDragIcon)) },


text:
{ WM_COMPAREITEM, 0, 0, 0, AfxSig_iis, (AFX_PMSG)(AFX_PMSGW) (static_cast< int (AFX_MSG_CALL CWnd::*)(int, LPCOMPAREITEMSTRUCT) > ( &ThisClass :: OnCompareItem)) },


text:
{ WM_COMPAREITEM+WM_REFLECT_BASE, 0, 0, 0, AfxSig_is, (AFX_PMSG)(AFX_PMSGW) (static_cast< int (AFX_MSG_CALL CWnd::*)(LPCOMPAREITEMSTRUCT) > ( &ThisClass :: CompareItem)) },


text:
{ WM_COMPACTING, 0, 0, 0, AfxSig_vw, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT) > ( &ThisClass :: OnCompacting)) },


text:
{ WM_NCCREATE, 0, 0, 0, AfxSig_is, (AFX_PMSG)(AFX_PMSGW) (static_cast< BOOL (AFX_MSG_CALL CWnd::*)(LPCREATESTRUCT) > ( &ThisClass :: OnNcCreate)) },


text:
{ WM_NCDESTROY, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnNcDestroy)) },


text:
{ WM_NCCALCSIZE, 0, 0, 0, AfxSig_vCALC, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(BOOL, NCCALCSIZE_PARAMS*) > ( &ThisClass :: OnNcCalcSize)) },


text:
{ WM_NCHITTEST, 0, 0, 0, AfxSig_l_p, (AFX_PMSG)(AFX_PMSGW) (static_cast< LRESULT (AFX_MSG_CALL CWnd::*)(CPoint) > (&ThisClass :: OnNcHitTest)) },


text:
{ WM_NCPAINT, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnNcPaint)) },


text:
{ WM_NCACTIVATE, 0, 0, 0, AfxSig_bb, (AFX_PMSG)(AFX_PMSGW) (static_cast< BOOL (AFX_MSG_CALL CWnd::*)(BOOL) > ( &ThisClass :: OnNcActivate)) },


text:
{ WM_GETDLGCODE, 0, 0, 0, AfxSig_wv, (AFX_PMSG)(AFX_PMSGW) (static_cast< UINT (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnGetDlgCode)) },


text:
{ WM_NCMOUSEMOVE, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnNcMouseMove)) },


text:
{ WM_NCMOUSEHOVER, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnNcMouseHover)) },


text:
{ WM_NCMOUSELEAVE, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnNcMouseLeave)) },


text:
{ WM_NCLBUTTONDOWN, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnNcLButtonDown)) },


text:
{ WM_NCLBUTTONUP, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnNcLButtonUp)) },


text:
{ WM_NCLBUTTONDBLCLK, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnNcLButtonDblClk)) },


text:
{ WM_NCRBUTTONDOWN, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnNcRButtonDown)) },


text:
{ WM_NCRBUTTONUP, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnNcRButtonUp)) },


text:
{ WM_NCRBUTTONDBLCLK, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnNcRButtonDblClk)) },


text:
{ WM_NCMBUTTONDOWN, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnNcMButtonDown)) },


text:
{ WM_NCMBUTTONUP, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnNcMButtonUp)) },


text:
{ WM_NCMBUTTONDBLCLK, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnNcMButtonDblClk)) },


text:
{ WM_NCXBUTTONDOWN, 0, 0, 0, AfxSig_MOUSE_NCXBUTTON, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(short, UINT, CPoint) > ( &ThisClass :: OnNcXButtonDown)) },


text:
{ WM_NCXBUTTONUP, 0, 0, 0, AfxSig_MOUSE_NCXBUTTON, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(short, UINT, CPoint) > ( &ThisClass :: OnNcXButtonUp)) },


text:
{ WM_NCXBUTTONDBLCLK, 0, 0, 0, AfxSig_MOUSE_NCXBUTTON, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(short, UINT, CPoint) > ( &ThisClass :: OnNcXButtonDblClk)) },


text:
{ WM_KEYDOWN, 0, 0, 0, AfxSig_vwww, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT, UINT) > ( &ThisClass :: OnKeyDown)) },


text:
{ WM_KEYUP, 0, 0, 0, AfxSig_vwww, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT, UINT) > ( &ThisClass :: OnKeyUp)) },


text:
{ WM_HOTKEY, 0, 0, 0, AfxSig_v_u_uu, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT, UINT) > ( &ThisClass :: OnHotKey)) },


text:
{ WM_CHAR, 0, 0, 0, AfxSig_vwww, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT, UINT) > ( &ThisClass :: OnChar)) },


text:
{ WM_UNICHAR, 0, 0, 0, AfxSig_vwww, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT, UINT) > ( &ThisClass :: OnUniChar)) },


text:
{ WM_DEADCHAR, 0, 0, 0, AfxSig_vwww, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT, UINT) > ( &ThisClass :: OnDeadChar)) },


text:
{ WM_SYSKEYDOWN, 0, 0, 0, AfxSig_vwww, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT, UINT) > ( &ThisClass :: OnSysKeyDown)) },


text:
{ WM_SYSKEYUP, 0, 0, 0, AfxSig_vwww, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT, UINT) > ( &ThisClass :: OnSysKeyUp)) },


text:
{ WM_SYSCHAR, 0, 0, 0, AfxSig_vwww, (AFX_PMSG)(AFX_PMSGW) (static_cast<void (AFX_MSG_CALL CWnd::*)(UINT, UINT, UINT) > ( &ThisClass :: OnSysChar)) },


text:
{ WM_SYSDEADCHAR, 0, 0, 0, AfxSig_vwww, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT, UINT) > ( &ThisClass :: OnSysDeadChar)) },


text:
{ WM_SYSCOMMAND, 0, 0, 0, AfxSig_vwl, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, LPARAM) > ( &ThisClass :: OnSysCommand)) },


text:
{ WM_INPUTLANGCHANGE, 0, 0, 0, AfxSig_INPUTLANGCHANGE, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT) > ( &ThisClass :: OnInputLangChange)) },


text:
{ WM_INPUTLANGCHANGEREQUEST, 0, 0, 0, AfxSig_vww, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT) > ( &ThisClass :: OnInputLangChangeRequest)) },


text:
{ WM_APPCOMMAND, 0, 0, 0, AfxSig_APPCOMMAND, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CWnd*, UINT, UINT, UINT) > ( &ThisClass :: OnAppCommand)) },


text:
{ WM_INPUT, 0, 0, 0, AfxSig_RAWINPUT, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, HRAWINPUT) > ( &ThisClass :: OnRawInput)) },


text:
{ WM_INPUT_DEVICE_CHANGE, 0, 0, 0, AfxSig_INPUTDEVICECHANGE, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(unsigned short, HANDLE) > ( &ThisClass :: OnInputDeviceChange)) },


text:
{ WM_TCARD, 0, 0, 0, AfxSig_vwl, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, DWORD) > ( &ThisClass :: OnTCard)) },


text:
{ WM_TIMER, 0, 0, 0, AfxSig_v_up_v, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT_PTR) > ( &ThisClass :: OnTimer)) },


text:
{ WM_HSCROLL, 0, 0, 0, AfxSig_vwwW, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT, CScrollBar*) > ( &ThisClass :: OnHScroll)) },


text:
{ WM_HSCROLL+WM_REFLECT_BASE, 0, 0, 0, AfxSig_vwwx, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT) > ( &ThisClass :: HScroll)) },


text:
{ WM_VSCROLL, 0, 0, 0, AfxSig_vwwW, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT, CScrollBar*) > ( &ThisClass :: OnVScroll)) },


text:
{ WM_VSCROLL+WM_REFLECT_BASE, 0, 0, 0, AfxSig_vwwx, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT) > ( &ThisClass :: VScroll)) },


text:
{ WM_INITMENU, 0, 0, 0, AfxSig_vM, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CMenu*) > ( &ThisClass :: OnInitMenu)) },


text:
{ WM_INITMENUPOPUP, 0, 0, 0, AfxSig_vMwb, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CMenu*, UINT, BOOL) > ( &ThisClass :: OnInitMenuPopup)) },


text:
{ WM_MENUSELECT, 0, 0, 0, AfxSig_vwwh, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT, HMENU) > ( &ThisClass :: OnMenuSelect)) },


text:
{ WM_MENUCHAR, 0, 0, 0, AfxSig_lwwM, (AFX_PMSG)(AFX_PMSGW) (static_cast< LRESULT (AFX_MSG_CALL CWnd::*)(UINT, UINT, CMenu*) > ( &ThisClass :: OnMenuChar)) },


text:
{ WM_MENURBUTTONUP, 0, 0, 0, AfxSig_v_u_M, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CMenu*) > ( &ThisClass :: OnMenuRButtonUp)) },


text:
{ WM_MENUDRAG, 0, 0, 0, AfxSig_u_u_M, (AFX_PMSG)(AFX_PMSGW) (static_cast< UINT (AFX_MSG_CALL CWnd::*)(UINT, CMenu*) > ( &ThisClass :: OnMenuDrag)) },


text:
{ WM_MENUGETOBJECT, 0, 0, 0, AfxSig_u_v_MENUGETOBJECTINFO, (AFX_PMSG)(AFX_PMSGW) (static_cast< UINT (AFX_MSG_CALL CWnd::*)(MENUGETOBJECTINFO*) > ( &ThisClass :: OnMenuGetObject)) },


text:
{ WM_UNINITMENUPOPUP, 0, 0, 0, AfxSig_v_M_u, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CMenu*, UINT) > ( &ThisClass :: OnUnInitMenuPopup)) },


text:
{ WM_NEXTMENU, 0, 0, 0, AfxSig_v_u_LPMDINEXTMENU, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, LPMDINEXTMENU) > ( &ThisClass :: OnNextMenu)) },


text:
{ WM_ENTERIDLE, 0, 0, 0, AfxSig_vwW, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CWnd*) > ( &ThisClass :: OnEnterIdle)) },


text:
{ WM_MOUSEMOVE, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnMouseMove)) },


text:
{ WM_MOUSEHOVER, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnMouseHover)) },


text:
{ WM_MOUSELEAVE, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnMouseLeave)) },


text:
{ WM_MOUSEWHEEL, 0, 0, 0, AfxSig_bwsp, (AFX_PMSG)(AFX_PMSGW) (static_cast< BOOL (AFX_MSG_CALL CWnd::*)(UINT, short, CPoint) > ( &ThisClass :: OnMouseWheel)) },


text:
{ WM_MOUSEHWHEEL, 0, 0, 0, AfxSig_MOUSEHWHEEL, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, short, CPoint) > ( &ThisClass :: OnMouseHWheel)) },


text:
{ WM_LBUTTONDOWN, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnLButtonDown)) },


text:
{ WM_LBUTTONUP, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnLButtonUp)) },


text:
{ WM_LBUTTONDBLCLK, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnLButtonDblClk)) },


text:
{ WM_RBUTTONDOWN, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnRButtonDown)) },


text:
{ WM_RBUTTONUP, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnRButtonUp)) },


text:
{ WM_RBUTTONDBLCLK, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnRButtonDblClk)) },


text:
{ WM_MBUTTONDOWN, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnMButtonDown)) },


text:
{ WM_MBUTTONUP, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnMButtonUp)) },


text:
{ WM_MBUTTONDBLCLK, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, CPoint) > ( &ThisClass :: OnMButtonDblClk)) },


text:
{ WM_XBUTTONDOWN, 0, 0, 0, AfxSig_MOUSE_XBUTTON, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT, CPoint) > ( &ThisClass :: OnXButtonDown)) },


text:
{ WM_XBUTTONUP, 0, 0, 0, AfxSig_MOUSE_XBUTTON, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT, CPoint) > ( &ThisClass :: OnXButtonUp)) },


text:
{ WM_XBUTTONDBLCLK, 0, 0, 0, AfxSig_MOUSE_XBUTTON, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT, CPoint) > ( &ThisClass :: OnXButtonDblClk)) },


text:
{ WM_PARENTNOTIFY, 0, 0, 0, AfxSig_vwl, (AFX_PMSG)(AFX_PMSGW) (static_cast<void (AFX_MSG_CALL CWnd::*)(UINT, LPARAM) > ( &ThisClass :: OnParentNotify)) },


text:
{ WM_PARENTNOTIFY+WM_REFLECT_BASE, 0, 0, 0, AfxSig_vwl, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, LPARAM) > ( &ThisClass :: ParentNotify)) },


text:
{ WM_NOTIFYFORMAT, 0, 0, 0, AfxSig_u_W_u, (AFX_PMSG)(AFX_PMSGW) (static_cast< UINT (AFX_MSG_CALL CWnd::*)(CWnd*, UINT) > ( &ThisClass :: OnNotifyFormat)) },


text:
{ WM_MDIACTIVATE, 0, 0, 0, AfxSig_vbWW, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(BOOL, CWnd*, CWnd*) > ( &ThisClass :: OnMDIActivate)) },


text:
{ WM_RENDERFORMAT, 0, 0, 0, AfxSig_vw, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT) > ( &ThisClass :: OnRenderFormat)) },


text:
{ WM_RENDERALLFORMATS, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnRenderAllFormats)) },


text:
{ WM_DESTROYCLIPBOARD, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnDestroyClipboard)) },


text:
{ WM_DRAWCLIPBOARD, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnDrawClipboard)) },


text:
{ WM_PAINTCLIPBOARD, 0, 0, 0, AfxSig_vWh, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CWnd*, HGLOBAL) > ( &ThisClass :: OnPaintClipboard)) },


text:
{ WM_VSCROLLCLIPBOARD, 0, 0, 0, AfxSig_vWww, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CWnd*, UINT, UINT) > ( &ThisClass :: OnVScrollClipboard)) },


text:
{ WM_CONTEXTMENU, 0, 0, 0, AfxSig_vWp, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CWnd*, CPoint) > ( &ThisClass :: OnContextMenu)) },


text:
{ WM_SIZECLIPBOARD, 0, 0, 0, AfxSig_vWh, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CWnd*, HGLOBAL)> ( &ThisClass :: OnSizeClipboard)) },


text:
{ WM_ASKCBFORMATNAME, 0, 0, 0, AfxSig_vwl, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, LPTSTR) > ( &ThisClass :: OnAskCbFormatName)) },


text:
{ WM_CHANGECBCHAIN, 0, 0, 0, AfxSig_vhh, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(HWND, HWND) > ( &ThisClass :: OnChangeCbChain)) },


text:
{ WM_HSCROLLCLIPBOARD, 0, 0, 0, AfxSig_vWww, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CWnd*, UINT, UINT) > ( &ThisClass :: OnHScrollClipboard)) },


text:
{ WM_CLIPBOARDUPDATE, 0, 0, 0, AfxSig_v_v_v, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnClipboardUpdate)) },


text:
{ WM_QUERYNEWPALETTE, 0, 0, 0, AfxSig_bv, (AFX_PMSG)(AFX_PMSGW) (static_cast< BOOL (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnQueryNewPalette)) },


text:
{ WM_PALETTECHANGED, 0, 0, 0, AfxSig_vW, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CWnd*) > ( &ThisClass :: OnPaletteChanged)) },


text:
{ WM_PALETTEISCHANGING, 0, 0, 0, AfxSig_vW, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CWnd*) > ( &ThisClass :: OnPaletteIsChanging)) },


text:
{ WM_DROPFILES, 0, 0, 0, AfxSig_vh, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(HDROP) > ( &ThisClass :: OnDropFiles)) },


text:
{ WM_WINDOWPOSCHANGING, 0, 0, 0, AfxSig_vPOS, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(WINDOWPOS*) > ( &ThisClass :: OnWindowPosChanging)) },


text:
{ WM_WINDOWPOSCHANGED, 0, 0, 0, AfxSig_vPOS, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(WINDOWPOS*) > ( &ThisClass :: OnWindowPosChanged)) },


text:
{ WM_EXITMENULOOP, 0, 0, 0, AfxSig_vb, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(BOOL) > ( &ThisClass :: OnExitMenuLoop)) },


text:
{ WM_ENTERMENULOOP, 0, 0, 0, AfxSig_vb, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(BOOL) > ( &ThisClass :: OnEnterMenuLoop)) },


text:
{ WM_STYLECHANGED, 0, 0, 0, AfxSig_viSS, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(int, LPSTYLESTRUCT) > ( &ThisClass :: OnStyleChanged)) },


text:
{ WM_STYLECHANGING, 0, 0, 0, AfxSig_viSS, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(int, LPSTYLESTRUCT) > ( &ThisClass :: OnStyleChanging)) },


text:
{ WM_SIZING, 0, 0, 0, AfxSig_vwSIZING, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, LPRECT) > ( &ThisClass :: OnSizing)) },


text:
{ WM_MOVING, 0, 0, 0, AfxSig_vwMOVING, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, LPRECT) > ( &ThisClass :: OnMoving)) },


text:
{ WM_ENTERSIZEMOVE, 0, 0, 0, AfxSig_v_v_v, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnEnterSizeMove)) },


text:
{ WM_EXITSIZEMOVE, 0, 0, 0, AfxSig_v_v_v, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnExitSizeMove)) },


text:
{ WM_CAPTURECHANGED, 0, 0, 0, AfxSig_vW2, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(CWnd*) > ( &ThisClass :: OnCaptureChanged)) },


text:
{ WM_DEVICECHANGE, 0, 0, 0, AfxSig_bwl, (AFX_PMSG)(AFX_PMSGW) (static_cast< BOOL (AFX_MSG_CALL CWnd::*)(UINT, DWORD_PTR) > ( &ThisClass :: OnDeviceChange)) },


text:
{ WM_POWERBROADCAST, 0, 0, 0, AfxSig_u_u_l, (AFX_PMSG)(AFX_PMSGW) (static_cast< UINT (AFX_MSG_CALL CWnd::*)(UINT, LPARAM) > ( &ThisClass :: OnPowerBroadcast)) },


text:
{ WM_USERCHANGED, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnUserChanged)) },


text:
{ WM_CHANGEUISTATE, 0, 0, 0, AfxSig_vww2, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT) > ( &ThisClass :: OnChangeUIState)) },


text:
{ WM_UPDATEUISTATE, 0, 0, 0, AfxSig_vww2, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(UINT, UINT) > ( &ThisClass :: OnUpdateUIState)) },


text:
{ WM_QUERYUISTATE, 0, 0, 0, AfxSig_wv, (AFX_PMSG)(AFX_PMSGW) (static_cast< UINT (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnQueryUIState)) },


text:
{ WM_THEMECHANGED, 0, 0, 0, AfxSig_l, (AFX_PMSG)(AFX_PMSGW) (static_cast< LRESULT (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnThemeChanged)) },


text:
{ WM_DWMCOMPOSITIONCHANGED, 0, 0, 0, AfxSig_vv, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnCompositionChanged)) },


text:
{ WM_DWMNCRENDERINGCHANGED, 0, 0, 0, AfxSig_vb, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(BOOL) > ( &ThisClass :: OnNcRenderingChanged)) },


text:
{ WM_DWMCOLORIZATIONCOLORCHANGED, 0, 0, 0, AfxSig_vww, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(DWORD, BOOL) > ( &ThisClass :: OnColorizationColorChanged)) },


text:
{ WM_DWMWINDOWMAXIMIZEDCHANGE, 0, 0, 0, AfxSig_vb, (AFX_PMSG)(AFX_PMSGW) (static_cast< void (AFX_MSG_CALL CWnd::*)(BOOL) > ( &ThisClass :: OnWindowMaximizedChange)) },


text:
{ WM_DWMSENDICONICTHUMBNAIL, 0, 0, 0, AfxSig_b_v_ii, (AFX_PMSG) (AFX_PMSGW) (static_cast< BOOL (AFX_MSG_CALL CWnd::*)(int, int) > ( &ThisClass :: OnSendIconicThumbnail)) },


text:
{ WM_DWMSENDICONICLIVEPREVIEWBITMAP, 0, 0, 0, AfxSig_b_v_v, (AFX_PMSG) (AFX_PMSGW) (static_cast< BOOL (AFX_MSG_CALL CWnd::*)(void) > ( &ThisClass :: OnSendIconicLivePreviewBitmap)) },


text:
{ message, 0, 0, 0, AfxSig_lwl, (AFX_PMSG)(AFX_PMSGW) (static_cast< LRESULT (AFX_MSG_CALL CWnd::*)(WPARAM, LPARAM) > (memberFxn)) },


text:
{ 0xC000, 0, 0, 0, (UINT_PTR)(UINT*)(&nMessageVariable), (AFX_PMSG)(AFX_PMSGW) (static_cast< LRESULT (AFX_MSG_CALL CWnd::*)(WPARAM, LPARAM) > (memberFxn)) },


text:
{ message, 0, 0, 0, AfxSig_vwl, (AFX_PMSG)(AFX_PMSGT) (static_cast< void (AFX_MSG_CALL CWinThread::*)(WPARAM, LPARAM) > (memberFxn)) },


text:
{ 0xC000, 0, 0, 0, (UINT_PTR)(UINT*)(&nMessageVariable), (AFX_PMSG)(AFX_PMSGT) (static_cast< void (AFX_MSG_CALL CWinThread::*)(WPARAM, LPARAM) > (memberFxn)) },


text:
(This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr)


text:
(This)->lpVtbl -> TranslateAccelerator(This,hWnd,nMessage,wParam,lParam,bstrGuidCmdGroup,nCmdID,dwRetVal)


text:
(This)->lpVtbl -> CreateControlLicEx(This,lpTricsData,hWnd,pStream,ppUnk,riidAdvise,punkAdvise,bstrLic)


text:
{ 0xC002, 0, (UINT)iVerb, (UINT)iVerb, (UINT)-1, (AFX_PMSG)(BOOL (AFX_MSG_CALL CCmdTarget::*)(LPMSG, HWND, LPCRECT))&memberFxn },


text:
{ 0xC002, 0, 1, 1, idsVerbName, (AFX_PMSG)(BOOL (AFX_MSG_CALL CCmdTarget::*)(LPMSG, HWND, LPCRECT))&memberFxn },


text:
_CRT_DEPRECATE_TEXT( "This function or variable may be unsafe. Consider using " #_Replacement " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")


text:
message("" __FILE__ "(" _CRT_STRINGIZE(__LINE__) ") : warning CRT0000 : " _CRT_STRINGIZE(description))


text:
_CRT_DEPRECATE_TEXT( "The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " #_NewName ". See online help for details.")


text:
_CRT_DEPRECATE_TEXT( "This function or variable has been superceded by newer library " "or operating system functionality. Consider using " #_NewItem " " "instead. See online help for details.")


text:
extern "C++" { template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size]) _CRT_SECURE_CPP_NOTHROW { return _FuncName(_Dst, _Size); } }


text:
extern "C++" { template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size], _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { return _FuncName(_Dst, _Size, _TArg1); } }


text:
extern "C++" { template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { return _FuncName(_Dst, _Size, _TArg1, _TArg2); } }


text:
extern "C++" { template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { return _FuncName(_Dst, _Size, _TArg1, _TArg2, _TArg3); } }


text:
extern "C++" { template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3, _TType4 _TArg4) _CRT_SECURE_CPP_NOTHROW { return _FuncName(_Dst, _Size, _TArg1, _TArg2, _TArg3, _TArg4); } }


text:
extern "C++" { template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _DstType (&_Dst)[_Size], _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { return _FuncName(_HArg1, _Dst, _Size, _TArg1); } }


text:
extern "C++" { template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _DstType (&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { return _FuncName(_HArg1, _Dst, _Size, _TArg1, _TArg2); } }


text:
extern "C++" { template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _DstType (&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { return _FuncName(_HArg1, _Dst, _Size, _TArg1, _TArg2, _TArg3); } }


text:
extern "C++" { template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _HType2 _HArg2, _DstType (&_Dst)[_Size]) _CRT_SECURE_CPP_NOTHROW { return _FuncName(_HArg1, _HArg2, _Dst, _Size); } }


text:
extern "C++" { __pragma(warning(push)); __pragma(warning(disable: 4793)); template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size], _TType1 _TArg1, ...) _CRT_SECURE_CPP_NOTHROW { va_list _ArgList; __crt_va_start(_ArgList, _TArg1); return _VFuncName(_Dst, _Size, _TArg1, _ArgList); } __pragma(warning(pop)); }


text:
extern "C++" { __pragma(warning(push)); __pragma(warning(disable: 4793)); template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2, ...) _CRT_SECURE_CPP_NOTHROW { va_list _ArgList; __crt_va_start(_ArgList, _TArg2); return _VFuncName(_Dst, _Size, _TArg1, _TArg2, _ArgList); } __pragma(warning(pop)); }


text:
extern "C++" { template <size_t _DriveSize, size_t _DirSize, size_t _NameSize, size_t _ExtSize> inline _ReturnType __CRTDECL _FuncName( _In_z_ _DstType const* _Src, _Post_z_ _DstType (&_Drive)[_DriveSize], _Post_z_ _DstType (&_Dir)[_DirSize], _Post_z_ _DstType (&_Name)[_NameSize], _Post_z_ _DstType (&_Ext)[_ExtSize] ) _CRT_SECURE_CPP_NOTHROW { return _FuncName(_Src, _Drive, _DriveSize, _Dir, _DirSize, _Name, _NameSize, _Ext, _ExtSize); } }


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _FuncName##_s, _SalAttributeDst, _DstType, _Dst)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _FuncName##_s, _DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _FuncName##_s, _DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _FuncName##_s, _DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_4_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _FuncName##_s, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3, _TType4, _TArg4)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_1_1_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _FuncName##_s, _HType1, _HArg1, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_2_0_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _FuncName##_s, _HType1, _HArg1, _HType2, _HArg2, _SalAttributeDst, _DstType, _Dst)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_ARGLIST_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _CC, _FuncName, _FuncName##_s, _VFuncName, _VFuncName##_s, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_ARGLIST_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _CC, _FuncName, _VFuncName, _VFuncName##_s, _DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_SIZE_EX(_DeclSpec, _FuncName, _FuncName##_s, _DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_SIZE_EX(_DeclSpec, _FuncName, _FuncName##_s, _DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_0_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _FuncName##_s, _SalAttributeDst, _DstType, _Dst)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _FuncName##_s, _SalAttributeDst, _DstType, _DstType, _Dst, _TType1, _TArg1)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _FuncName##_s, _DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _FuncName##_s, _DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_4_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _FuncName##_s, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3, _TType4, _TArg4)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_1_1_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _FuncName##_s, _HType1, _HArg1, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_2_0_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _FuncName##_s, _HType1, _HArg1, _HType2, _HArg2, _SalAttributeDst, _DstType, _Dst)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_1_ARGLIST_EX(_ReturnType, _ReturnPolicy, _DeclSpec, __cdecl, _FuncName, _FuncName##_s, _VFuncName, _VFuncName##_s, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_SIZE_EX(_DeclSpec, _FuncName, _FuncName##_s, _DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_3_SIZE_EX(_DeclSpec, _FuncName, _FuncName##_s, _DstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3)


text:
__inline _ReturnType __CRTDECL __insecure_##_FuncName(_SalAttributeDst _DstType *_Dst) { _DeclSpec _ReturnType __cdecl _FuncName(_DstType *_Dst); return _FuncName(_Dst); } extern "C++" { template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_T &_Dst) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst)); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(const _T &_Dst) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst)); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_DstType * &_Dst) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_Dst); } template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size]) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, _Size), _Dst); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1]) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, 1), _Dst); } }


text:
__inline _ReturnType __CRTDECL __insecure_##_FuncName(_SalAttributeDst _DstType *_Dst) { _DeclSpec _ReturnType __cdecl _FuncName(_DstType *_Dst); return _FuncName(_Dst); } extern "C++" { template <typename _T> inline _CRT_INSECURE_DEPRECATE(_FuncName##_s) _ReturnType __CRTDECL _FuncName(_T &_Dst) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst)); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_FuncName##_s) _ReturnType __CRTDECL _FuncName(const _T &_Dst) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst)); } template <> inline _CRT_INSECURE_DEPRECATE(_FuncName##_s) _ReturnType __CRTDECL _FuncName(_DstType * &_Dst) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_Dst); } template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size]) _CRT_SECURE_CPP_NOTHROW { size_t _SizeRead = 0; errno_t _Err = _FuncName##_s(_Dst + 2, (_Size - 2) < ((size_t)_Dst[0]) ? (_Size - 2) : ((size_t)_Dst[0]), &_SizeRead); _Dst[1] = (_DstType)(_SizeRead); return (_Err == 0 ? _Dst + 2 : 0); } template <> inline _CRT_INSECURE_DEPRECATE(_FuncName##_s) _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1]) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName((_DstType *)_Dst); } template <> inline _CRT_INSECURE_DEPRECATE(_FuncName##_s) _ReturnType __CRTDECL _FuncName<2>(_DstType (&_Dst)[2]) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName((_DstType *)_Dst); } }


text:
__inline _ReturnType __CRTDECL __insecure_##_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1) { _DeclSpec _ReturnType __cdecl _FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1); return _FuncName(_Dst, _TArg1); } extern "C++" { template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_DstType * &_Dst, _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_Dst, _TArg1); } template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, _Size, _TArg1), _Dst); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, 1, _TArg1), _Dst); } }


text:
__inline _ReturnType __CRTDECL __insecure_##_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { _DeclSpec _ReturnType __cdecl _FuncName(_DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2); return _FuncName(_Dst, _TArg1, _TArg2); } extern "C++" { template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_DstType * &_Dst, _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_Dst, _TArg1, _TArg2); } template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, _Size, _TArg1, _TArg2), _Dst); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, 1, _TArg1, _TArg2), _Dst); } }


text:
__inline _ReturnType __CRTDECL __insecure_##_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) { _DeclSpec _ReturnType __cdecl _FuncName(_DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3); return _FuncName(_Dst, _TArg1, _TArg2, _TArg3); } extern "C++" { template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2, _TArg3); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2, _TArg3); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_DstType * &_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_Dst, _TArg1, _TArg2, _TArg3); } template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, _Size, _TArg1, _TArg2, _TArg3), _Dst); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, 1, _TArg1, _TArg2, _TArg3), _Dst); } }


text:
__inline _ReturnType __CRTDECL __insecure_##_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3, _TType4 _TArg4) { _DeclSpec _ReturnType __cdecl _FuncName(_DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3, _TType4 _TArg4); return _FuncName(_Dst, _TArg1, _TArg2, _TArg3, _TArg4); } extern "C++" { template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3, _TType4 _TArg4) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2, _TArg3, _TArg4); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3, _TType4 _TArg4) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2, _TArg3, _TArg4); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_DstType * &_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3, _TType4 _TArg4) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_Dst, _TArg1, _TArg2, _TArg3, _TArg4); } template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3, _TType4 _TArg4) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, _Size, _TArg1, _TArg2, _TArg3, _TArg4), _Dst); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3, _TType4 _TArg4) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, 1, _TArg1, _TArg2, _TArg3, _TArg4), _Dst); } }


text:
__inline _ReturnType __CRTDECL __insecure_##_FuncName(_HType1 _HArg1, _SalAttributeDst _DstType *_Dst, _TType1 _TArg1) { _DeclSpec _ReturnType __cdecl _FuncName(_HType1 _HArg1, _DstType *_Dst, _TType1 _TArg1); return _FuncName(_HArg1, _Dst, _TArg1); } extern "C++" { template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _T &_Dst, _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_HArg1, static_cast<_DstType *>(_Dst), _TArg1); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, const _T &_Dst, _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_HArg1, static_cast<_DstType *>(_Dst), _TArg1); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _DstType * &_Dst, _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_HArg1, _Dst, _TArg1); } template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _DstType (&_Dst)[_Size], _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_HArg1, _Dst, _Size, _TArg1), _Dst); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName<1>(_HType1 _HArg1, _DstType (&_Dst)[1], _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_HArg1, _Dst, 1, _TArg1), _Dst); } }


text:
__inline _ReturnType __CRTDECL __insecure_##_FuncName(_HType1 _HArg1, _HType2 _HArg2, _SalAttributeDst _DstType *_Dst) { _DeclSpec _ReturnType __cdecl _FuncName(_HType1 _HArg1, _HType2 _HArg2, _DstType *_Dst); return _FuncName(_HArg1, _HArg2, _Dst); } extern "C++" { template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _HType2 _HArg2, _T &_Dst) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_HArg1, _HArg2, static_cast<_DstType *>(_Dst)); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _HType2 _HArg2, const _T &_Dst) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_HArg1, _HArg2, static_cast<_DstType *>(_Dst)); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _HType2 _HArg2, _DstType * &_Dst) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_HArg1, _HArg2, _Dst); } template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_HType1 _HArg1, _HType2 _HArg2, _DstType (&_Dst)[_Size]) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_HArg1, _HArg2, _Dst, _Size), _Dst); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName<1>(_HType1 _HArg1, _HType2 _HArg2, _DstType (&_Dst)[1]) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_HArg1, _HArg2, _Dst, 1), _Dst); } }


text:
__inline _ReturnType __CRTDECL __insecure_##_VFuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, va_list _ArgList) { _DeclSpec _ReturnType _CC _VFuncName(_DstType *_Dst, _TType1 _TArg1, va_list _ArgList); return _VFuncName(_Dst, _TArg1, _ArgList); } extern "C++" { __pragma(warning(push)); __pragma(warning(disable: 4793)); template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, ...) _CRT_SECURE_CPP_NOTHROW { va_list _ArgList; __crt_va_start(_ArgList, _TArg1); return __insecure_##_VFuncName(static_cast<_DstType *>(_Dst), _TArg1, _ArgList); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, ...) _CRT_SECURE_CPP_NOTHROW { va_list _ArgList; __crt_va_start(_ArgList, _TArg1); return __insecure_##_VFuncName(static_cast<_DstType *>(_Dst), _TArg1, _ArgList); } __pragma(warning(pop)); __pragma(warning(push)); __pragma(warning(disable: 4793)); template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_DstType * &_Dst, _TType1 _TArg1, ...) _CRT_SECURE_CPP_NOTHROW { va_list _ArgList; __crt_va_start(_ArgList, _TArg1); return __insecure_##_VFuncName(_Dst, _TArg1, _ArgList); } __pragma(warning(pop)); __pragma(warning(push)); __pragma(warning(disable: 4793)); template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_DstType (&_Dst)[_Size], _TType1 _TArg1, ...) _CRT_SECURE_CPP_NOTHROW { va_list _ArgList; __crt_va_start(_ArgList, _TArg1); _ReturnPolicy(_SecureVFuncName(_Dst, _Size, _TArg1, _ArgList), _Dst); } __pragma(warning(pop)); __pragma(warning(push)); __pragma(warning(disable: 4793)); template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1 _TArg1, ...) _CRT_SECURE_CPP_NOTHROW { va_list _ArgList; __crt_va_start(_ArgList, _TArg1); _ReturnPolicy(_SecureVFuncName(_Dst, 1, _TArg1, _ArgList), _Dst); } __pragma(warning(pop)); template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureVFuncName) _ReturnType __CRTDECL _VFuncName(_T &_Dst, _TType1 _TArg1, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_VFuncName(static_cast<_DstType *>(_Dst), _TArg1, _ArgList); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureVFuncName) _ReturnType __CRTDECL _VFuncName(const _T &_Dst, _TType1 _TArg1, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_VFuncName(static_cast<_DstType *>(_Dst), _TArg1, _ArgList); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureVFuncName) _ReturnType __CRTDECL _VFuncName(_DstType *&_Dst, _TType1 _TArg1, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_VFuncName(_Dst, _TArg1, _ArgList); } template <size_t _Size> inline _ReturnType __CRTDECL _VFuncName(_DstType (&_Dst)[_Size], _TType1 _TArg1, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureVFuncName(_Dst, _Size, _TArg1, _ArgList), _Dst); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureVFuncName) _ReturnType __CRTDECL _VFuncName<1>(_DstType (&_Dst)[1], _TType1 _TArg1, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureVFuncName(_Dst, 1, _TArg1, _ArgList), _Dst); } }


text:
__inline _ReturnType __CRTDECL __insecure_##_VFuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, va_list _ArgList) { _DeclSpec _ReturnType _CC _VFuncName(_DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, va_list _ArgList); return _VFuncName(_Dst, _TArg1, _TArg2, _ArgList); } extern "C++" { __pragma(warning(push)); __pragma(warning(disable: 4793)); template <typename _T> inline _CRT_INSECURE_DEPRECATE(_FuncName##_s) _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2, ...) _CRT_SECURE_CPP_NOTHROW { va_list _ArgList; __crt_va_start(_ArgList, _TArg2); return __insecure_##_VFuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2, _ArgList); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_FuncName##_s) _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, _TType2 _TArg2, ...) _CRT_SECURE_CPP_NOTHROW { va_list _ArgList; __crt_va_start(_ArgList, _TArg2); return __insecure_##_VFuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2, _ArgList); } __pragma(warning(pop)); __pragma(warning(push)); __pragma(warning(disable: 4793)); template <> inline _CRT_INSECURE_DEPRECATE(_FuncName##_s) _ReturnType __CRTDECL _FuncName(_DstType * &_Dst, _TType1 _TArg1, _TType2 _TArg2, ...) _CRT_SECURE_CPP_NOTHROW { va_list _ArgList; __crt_va_start(_ArgList, _TArg2); return __insecure_##_VFuncName(_Dst, _TArg1, _TArg2, _ArgList); } __pragma(warning(pop)); __pragma(warning(push)); __pragma(warning(disable: 4793)); template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2, ...) _CRT_SECURE_CPP_NOTHROW { va_list _ArgList; __crt_va_start(_ArgList, _TArg2); _ReturnPolicy(_SecureVFuncName(_Dst, _Size, _TArg1, _TArg2, _ArgList), _Dst); } __pragma(warning(pop)); __pragma(warning(push)); __pragma(warning(disable: 4793)); template <> inline _CRT_INSECURE_DEPRECATE(_FuncName##_s) _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1 _TArg1, _TType2 _TArg2, ...) _CRT_SECURE_CPP_NOTHROW { va_list _ArgList; __crt_va_start(_ArgList, _TArg2); _ReturnPolicy(_SecureVFuncName(_Dst, 1, _TArg1, _TArg2, _ArgList), _Dst); } __pragma(warning(pop)); template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureVFuncName) _ReturnType __CRTDECL _VFuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_VFuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2, _ArgList); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureVFuncName) _ReturnType __CRTDECL _VFuncName(const _T &_Dst, _TType1 _TArg1, _TType2 _TArg2, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_VFuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2, _ArgList); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureVFuncName) _ReturnType __CRTDECL _VFuncName(_DstType *&_Dst, _TType1 _TArg1, _TType2 _TArg2, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_VFuncName(_Dst, _TArg1, _TArg2, _ArgList); } template <size_t _Size> inline _ReturnType __CRTDECL _VFuncName(_SecureDstType (&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureVFuncName(_Dst, _Size, _TArg1, _TArg2, _ArgList), _Dst); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureVFuncName) _ReturnType __CRTDECL _VFuncName<1>(_DstType (&_Dst)[1], _TType1 _TArg1, _TType2 _TArg2, va_list _ArgList) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureVFuncName(_Dst, 1, _TArg1, _TArg2, _ArgList), _Dst); } }


text:
__inline size_t __CRTDECL __insecure_##_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2) { _DeclSpec size_t __cdecl _FuncName(_DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2); return _FuncName(_Dst, _TArg1, _TArg2); } extern "C++" { template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) size_t __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) size_t __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) size_t __CRTDECL _FuncName(_DstType * &_Dst, _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_Dst, _TArg1, _TArg2); } template <size_t _Size> inline size_t __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { size_t _Ret = 0; _SecureFuncName(&_Ret, _Dst, _Size, _TArg1, _TArg2); return (_Ret > 0 ? (_Ret - 1) : _Ret); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) size_t __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { size_t _Ret = 0; _SecureFuncName(&_Ret, _Dst, 1, _TArg1, _TArg2); return (_Ret > 0 ? (_Ret - 1) : _Ret); } }


text:
__inline size_t __CRTDECL __insecure_##_FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) { _DeclSpec size_t __cdecl _FuncName(_DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3); return _FuncName(_Dst, _TArg1, _TArg2, _TArg3); } extern "C++" { template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) size_t __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2, _TArg3); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) size_t __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2, _TArg3); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) size_t __CRTDECL _FuncName(_DstType * &_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_Dst, _TArg1, _TArg2, _TArg3); } template <size_t _Size> inline size_t __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { size_t _Ret = 0; _SecureFuncName(&_Ret, _Dst, _Size, _TArg1, _TArg2, _TArg3); return (_Ret > 0 ? (_Ret - 1) : _Ret); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) size_t __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { size_t _Ret = 0; _SecureFuncName(&_Ret, _Dst, 1, _TArg1, _TArg2, _TArg3); return (_Ret > 0 ? (_Ret - 1) : _Ret); } }


text:
extern "C++" { template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_T &_Dst) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst)); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(const _T &_Dst) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst)); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_DstType * &_Dst) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_Dst); } template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size]) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, _Size), _Dst); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1]) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, 1), _Dst); } }


text:
extern "C++" { template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_DstType * &_Dst, _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_Dst, _TArg1); } template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, _Size, _TArg1), _Dst); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1 _TArg1) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, 1, _TArg1), _Dst); } }


text:
__inline _ReturnType __CRTDECL __insecure_##_FuncName(_DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2)


text:
extern "C++" { template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_DstType * &_Dst, _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_Dst, _TArg1, _TArg2); } template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, _Size, _TArg1, _TArg2), _Dst); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1 _TArg1, _TType2 _TArg2) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, 1, _TArg1, _TArg2), _Dst); } }


text:
__inline _ReturnType __CRTDECL __insecure_##_FuncName(_DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3)


text:
extern "C++" { template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_T &_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2, _TArg3); } template <typename _T> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(const _T &_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(static_cast<_DstType *>(_Dst), _TArg1, _TArg2, _TArg3); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName(_DstType * &_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { return __insecure_##_FuncName(_Dst, _TArg1, _TArg2, _TArg3); } template <size_t _Size> inline _ReturnType __CRTDECL _FuncName(_SecureDstType (&_Dst)[_Size], _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, _Size, _TArg1, _TArg2, _TArg3), _Dst); } template <> inline _CRT_INSECURE_DEPRECATE(_SecureFuncName) _ReturnType __CRTDECL _FuncName<1>(_DstType (&_Dst)[1], _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3) _CRT_SECURE_CPP_NOTHROW { _ReturnPolicy(_SecureFuncName(_Dst, 1, _TArg1, _TArg2, _TArg3), _Dst); } }


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SalAttributeDst, _DstType, _Dst)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0_CGETS(_ReturnType, _DeclSpec, _FuncName, _SalAttributeDst, _DstType, _Dst)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_4_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3, _TType4)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_1_1_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _HType1, _HArg1, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_2_0_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _FuncName, _SecureFuncName, _HType1, _HArg1, _HType2, _HArg2, _SalAttributeDst, _DstType, _Dst)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_ARGLIST_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _CC, _FuncName, _SecureFuncName, _VFuncName, _SecureVFuncName, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_ARGLIST(_ReturnType, _ReturnPolicy, _DeclSpec, __cdecl, _FuncName, _VFuncName, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_ARGLIST_EX(_ReturnType, _ReturnPolicy, _DeclSpec, _CC, _FuncName, _VFuncName, _VFuncName##_s, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_2_SIZE_EX(_DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)


text:
__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_3_SIZE_EX(_DeclSpec, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3)


text:
__DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_0_EX(_ReturnType, _ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType _DstType, _Dst)


text:
__DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_0_EX(_ReturnType, _ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst)


text:
__DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_1_EX(_ReturnType, _ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType _DstType, _Dst, _TType1, _TArg1)


text:
__DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_1_EX(_ReturnType, _ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1)


text:
__DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_2_EX(_ReturnType, _ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)


text:
__DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_2_EX(_ReturnType, _ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2)


text:
__DECLARE_CPP_OVERLOAD_INLINE_FUNC_0_3_EX(_ReturnType, _ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3)


text:
__DEFINE_CPP_OVERLOAD_INLINE_FUNC_0_3_EX(_ReturnType, _ReturnPolicy, _FuncName, _SecureFuncName, _SecureDstType, _SalAttributeDst, _DstType, _Dst, _TType1, _TArg1, _TType2, _TArg2, _TType3, _TArg3)


text:
_CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl _FuncName(_SalAttributeDst _DstType *_Dst);


text:
_CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl _FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1);


text:
_CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl _FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2);


text:
_CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl _FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3);


text:
_CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl _FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3, _TType4 _TArg4);


text:
_CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl _FuncName(_HType1 _HArg1, _SalAttributeDst _DstType *_Dst, _TType1 _TArg1);


text:
_CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType __cdecl _FuncName(_HType1 _HArg1, _HType2 _HArg2, _SalAttributeDst _DstType *_Dst);


text:
_CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec _ReturnType _CC _FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, ...); _CRT_INSECURE_DEPRECATE(_SecureVFuncName) _DeclSpec _ReturnType _CC _VFuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, va_list _Args);


text:
_CRT_INSECURE_DEPRECATE(_FuncName##_s) _DeclSpec _ReturnType __cdecl _FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, ...); _CRT_INSECURE_DEPRECATE(_VFuncName##_s) _DeclSpec _ReturnType __cdecl _VFuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, va_list _Args);


text:
_CRT_INSECURE_DEPRECATE(_FuncName##_s) _DeclSpec _ReturnType _CC _FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, ...); _CRT_INSECURE_DEPRECATE(_VFuncName##_s) _DeclSpec _ReturnType _CC _VFuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, va_list _Args);


text:
_CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec size_t __cdecl _FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2);


text:
_CRT_INSECURE_DEPRECATE(_SecureFuncName) _DeclSpec size_t __cdecl _FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3);


text:
_CRT_INSECURE_DEPRECATE(_SecureFuncName) __inline _ReturnType __CRTDECL _FuncName(_DstType *_Dst, _TType1 _TArg1)


text:
_CRT_INSECURE_DEPRECATE(_SecureFuncName) __inline _ReturnType __CRTDECL _FuncName(_DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2)


text:
_CRT_INSECURE_DEPRECATE(_SecureFuncName) __inline _ReturnType __CRTDECL _FuncName(_DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, _TType3 _TArg3)


text:
_CRT_INSECURE_DEPRECATE(_FuncName##_s) _DeclSpec _ReturnType __cdecl _FuncName(_SalAttributeDst _DstType *_Dst);


text:
_CRT_INSECURE_DEPRECATE(_FuncName##_s) _DeclSpec _ReturnType _CC _FuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, ...); _CRT_INSECURE_DEPRECATE(_SecureVFuncName) _DeclSpec _ReturnType _CC _VFuncName(_SalAttributeDst _DstType *_Dst, _TType1 _TArg1, _TType2 _TArg2, va_list _Args);


text:
_CRT_DEPRECATE_TEXT( "function has been changed to conform with the ISO C standard, " "adding an extra character count parameter. To use the traditional " "Microsoft version, set _CRT_NON_CONFORMING_SWPRINTFS.")


text:
_CRT_DEPRECATE_TEXT( "wcstok has been changed to conform with the ISO C standard, " "adding an extra context parameter. To use the legacy Microsoft " "wcstok, define _CRT_NON_CONFORMING_WCSTOK.")


text:
{ __m128 _Tmp3, _Tmp2, _Tmp1, _Tmp0; _Tmp0 = _mm_shuffle_ps((row0), (row1), 0x44); _Tmp2 = _mm_shuffle_ps((row0), (row1), 0xEE); _Tmp1 = _mm_shuffle_ps((row2), (row3), 0x44); _Tmp3 = _mm_shuffle_ps((row2), (row3), 0xEE); (row0) = _mm_shuffle_ps(_Tmp0, _Tmp1, 0x88); (row1) = _mm_shuffle_ps(_Tmp0, _Tmp1, 0xDD); (row2) = _mm_shuffle_ps(_Tmp2, _Tmp3, 0x88); (row3) = _mm_shuffle_ps(_Tmp2, _Tmp3, 0xDD); }


text:
(PVOID)(LONG_PTR)InterlockedCompareExchange((LONG volatile *)(Destination), (LONG)(LONG_PTR)(ExChange), (LONG)(LONG_PTR)(Comperand))


text:
(((Number) & PROC_THREAD_ATTRIBUTE_NUMBER) | ((Thread != FALSE) ? PROC_THREAD_ATTRIBUTE_THREAD : 0) | ((Input != FALSE) ? PROC_THREAD_ATTRIBUTE_INPUT : 0) | ((Additive != FALSE) ? PROC_THREAD_ATTRIBUTE_ADDITIVE : 0))


text:
((COLORREF)((((BYTE)(k)|((WORD)((BYTE)(y))<<8))|(((DWORD)(BYTE)(m))<<16))|(((DWORD)(BYTE)(c))<<24)))


text:
(WINSTA_ENUMDESKTOPS | WINSTA_READATTRIBUTES | WINSTA_ACCESSCLIPBOARD | WINSTA_CREATEDESKTOP | WINSTA_WRITEATTRIBUTES | WINSTA_ACCESSGLOBALATOMS | WINSTA_EXITWINDOWS | WINSTA_ENUMERATE | WINSTA_READSCREEN)


text:
CreateWindowExA(0L, lpClassName, lpWindowName, dwStyle, x, y,nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam)


text:
CreateWindowExW(0L, lpClassName, lpWindowName, dwStyle, x, y,nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam)


text:
(((iType<pInfo->dwTypeIDMainSize)&&(pInfo->dwTypeIDMainOffset>0))?*((DWORD*)((ULONG_PTR)pInfo+pInfo->dwTypeIDMainOffset)+iType):0)


text:
(((iType<pInfo->dwTypeIDMUISize)&&(pInfo->dwTypeIDMUIOffset>0))?*((DWORD*)((ULONG_PTR)pInfo+pInfo->dwTypeIDMUIOffset)+iType):0)


text:
(PERF_SIZE_DWORD | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_TICK | PERF_DELTA_COUNTER | PERF_DISPLAY_PER_SEC)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_TICK | PERF_DELTA_COUNTER | PERF_DISPLAY_PERCENT)


text:
(PERF_SIZE_DWORD | PERF_TYPE_COUNTER | PERF_COUNTER_QUEUELEN | PERF_TIMER_TICK | PERF_DELTA_COUNTER | PERF_DISPLAY_NO_SUFFIX)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_QUEUELEN | PERF_TIMER_TICK | PERF_DELTA_COUNTER | PERF_DISPLAY_NO_SUFFIX)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_QUEUELEN | PERF_TIMER_100NS | PERF_DELTA_COUNTER | PERF_DISPLAY_NO_SUFFIX)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_QUEUELEN | PERF_OBJECT_TIMER | PERF_DELTA_COUNTER | PERF_DISPLAY_NO_SUFFIX)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_TICK | PERF_DELTA_COUNTER | PERF_DISPLAY_PER_SEC)


text:
(PERF_SIZE_DWORD | PERF_TYPE_COUNTER | PERF_COUNTER_FRACTION | PERF_DELTA_COUNTER | PERF_DELTA_BASE | PERF_DISPLAY_PERCENT)


text:
(PERF_SIZE_DWORD | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_TICK | PERF_DELTA_COUNTER | PERF_DISPLAY_NO_SUFFIX)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_TICK | PERF_DELTA_COUNTER | PERF_INVERSE_COUNTER | PERF_DISPLAY_PERCENT)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_OBJECT_TIMER | PERF_DELTA_COUNTER | PERF_DISPLAY_PERCENT)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_100NS | PERF_DELTA_COUNTER | PERF_DISPLAY_PERCENT)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_100NS | PERF_DELTA_COUNTER | PERF_INVERSE_COUNTER | PERF_DISPLAY_PERCENT)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_DELTA_COUNTER | PERF_TIMER_TICK | PERF_MULTI_COUNTER | PERF_DISPLAY_PERCENT)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_DELTA_COUNTER | PERF_MULTI_COUNTER | PERF_TIMER_TICK | PERF_INVERSE_COUNTER | PERF_DISPLAY_PERCENT)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_BASE | PERF_MULTI_COUNTER | PERF_DISPLAY_NOSHOW)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_DELTA_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_100NS | PERF_MULTI_COUNTER | PERF_DISPLAY_PERCENT)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_DELTA_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_100NS | PERF_MULTI_COUNTER | PERF_INVERSE_COUNTER | PERF_DISPLAY_PERCENT)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_ELAPSED | PERF_OBJECT_TIMER | PERF_DISPLAY_SECONDS)


text:
(PERF_SIZE_DWORD | PERF_TYPE_COUNTER | PERF_COUNTER_VALUE | PERF_DELTA_COUNTER | PERF_DISPLAY_NO_SUFFIX)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_VALUE | PERF_DELTA_COUNTER | PERF_DISPLAY_NO_SUFFIX)


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_PRECISION | PERF_TIMER_TICK | PERF_DELTA_COUNTER | PERF_DISPLAY_PERCENT )


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_PRECISION | PERF_TIMER_100NS | PERF_DELTA_COUNTER | PERF_DISPLAY_PERCENT )


text:
(PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_PRECISION | PERF_OBJECT_TIMER | PERF_DELTA_COUNTER | PERF_DISPLAY_PERCENT )


text:
do { if (((fd_set FAR *)(set))->fd_count < FD_SETSIZE) ((fd_set FAR *)(set))->fd_array[((fd_set FAR *)(set))->fd_count++]=(fd);} while(0)


text:
(CERT_SHA1_HASH_PROP_ID == (X) || CERT_MD5_HASH_PROP_ID == (X) || CERT_SIGNATURE_HASH_PROP_ID == (X))


text:
(CERT_ISSUER_PUBLIC_KEY_MD5_HASH_PROP_ID == (X) || CERT_SUBJECT_PUBLIC_KEY_MD5_HASH_PROP_ID == (X) || CERT_ISSUER_SERIAL_NUMBER_MD5_HASH_PROP_ID == (X) || CERT_SUBJECT_NAME_MD5_HASH_PROP_ID == (X))


text:
( CERT_QUERY_CONTENT_FLAG_CERT | CERT_QUERY_CONTENT_FLAG_CTL | CERT_QUERY_CONTENT_FLAG_CRL | CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL | CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL | CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED | CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED | CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED | CERT_QUERY_CONTENT_FLAG_PKCS10 | CERT_QUERY_CONTENT_FLAG_PFX | CERT_QUERY_CONTENT_FLAG_CERT_PAIR )


text:
( CERT_QUERY_FORMAT_FLAG_BINARY | CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED | CERT_QUERY_FORMAT_FLAG_ASN_ASCII_HEX_ENCODED )


text:
L"Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CertDllCreateCertificateChainEngine\\Config"


text:
( CERT_CHAIN_POLICY_IGNORE_NOT_TIME_VALID_FLAG | CERT_CHAIN_POLICY_IGNORE_CTL_NOT_TIME_VALID_FLAG | CERT_CHAIN_POLICY_IGNORE_NOT_TIME_NESTED_FLAG )


text:
( CERT_CHAIN_POLICY_IGNORE_END_REV_UNKNOWN_FLAG | CERT_CHAIN_POLICY_IGNORE_CTL_SIGNER_REV_UNKNOWN_FLAG | CERT_CHAIN_POLICY_IGNORE_CA_REV_UNKNOWN_FLAG | CERT_CHAIN_POLICY_IGNORE_ROOT_REV_UNKNOWN_FLAG )


text:
SCardIntroduceCardType(hContext, szCardName, pguidPrimaryProvider, rgguidInterfaces, dwInterfaceCount, pbAtr, pbAtrMask, cbAtrLen)


text:
{ PCUWSTR __ua_src; size_t __ua_size; PWSTR __ua_dst; __ua_src = (s); if (WSTR_ALIGNED(__ua_src)) { __ua_dst = (PWSTR)__ua_src; } else { __ua_size = __UA_WSTRSIZE(__ua_src); __ua_dst = (PWSTR)_alloca(__ua_size); memcpy(__ua_dst,__ua_src,__ua_size); } *(d) = (PCWSTR)__ua_dst; }


text:
(STANDARD_RIGHTS_REQUIRED | SC_MANAGER_CONNECT | SC_MANAGER_CREATE_SERVICE | SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_LOCK | SC_MANAGER_QUERY_LOCK_STATUS | SC_MANAGER_MODIFY_BOOT_CONFIG)


text:
(STANDARD_RIGHTS_REQUIRED | SERVICE_QUERY_CONFIG | SERVICE_CHANGE_CONFIG | SERVICE_QUERY_STATUS | SERVICE_ENUMERATE_DEPENDENTS | SERVICE_START | SERVICE_STOP | SERVICE_PAUSE_CONTINUE | SERVICE_INTERROGATE | SERVICE_USER_DEFINED_CONTROL)


text:
(((_dwOptions) &= ~MDM_MASK_BEARERMODE), ((_dwOptions) |= (((_bm)<<MDM_SHIFT_BEARERMODE)&MDM_MASK_BEARERMODE)))


text:
(((_dwOptions) &= ~MDM_MASK_PROTOCOLID), ((_dwOptions) |= (((_prot)<<MDM_SHIFT_PROTOCOLID)&MDM_MASK_PROTOCOLID)))


text:
(((_dwOptions) &= ~MDM_MASK_PROTOCOLDATA), ((_dwOptions) |= (((_pd)<<MDM_SHIFT_PROTOCOLDATA)&MDM_MASK_PROTOCOLDATA)))


text:
((((_pid )<<MDM_SHIFT_PROTOCOLID )&MDM_MASK_PROTOCOLID ) |(((_pdata)<<MDM_SHIFT_PROTOCOLDATA)&MDM_MASK_PROTOCOLDATA))


text:
((((_speed)<<MDM_SHIFT_HDLCPPP_SPEED)&MDM_MASK_HDLCPPP_SPEED) |(((_auth )<<MDM_SHIFT_HDLCPPP_AUTH )&MDM_MASK_HDLCPPP_AUTH ) |(((_ml )<<MDM_SHIFT_HDLCPPP_ML )&MDM_MASK_HDLCPPP_ML ))


text:
MDM_GEN_PROTOCOLINFO( MDM_PROTOCOLID_HDLCPPP, MDM_GEN_HDLCPPP_PROTOCOL_DATA ( MDM_HDLCPPP_SPEED_64K, MDM_HDLCPPP_AUTH_DEFAULT, MDM_HDLCPPP_ML_DEFAULT ) )


text:
MDM_GEN_PROTOCOLINFO( MDM_PROTOCOLID_HDLCPPP, MDM_GEN_HDLCPPP_PROTOCOL_DATA ( MDM_HDLCPPP_SPEED_56K, MDM_HDLCPPP_AUTH_DEFAULT, MDM_HDLCPPP_ML_DEFAULT ) )


text:
MDM_GEN_PROTOCOLINFO( MDM_PROTOCOLID_HDLCPPP, MDM_GEN_HDLCPPP_PROTOCOL_DATA ( MDM_HDLCPPP_SPEED_56K, MDM_HDLCPPP_AUTH_DEFAULT, MDM_HDLCPPP_ML_2 ) )


text:
MDM_GEN_PROTOCOLINFO( MDM_PROTOCOLID_HDLCPPP, MDM_GEN_HDLCPPP_PROTOCOL_DATA ( MDM_HDLCPPP_SPEED_56K, MDM_HDLCPPP_AUTH_PAP, MDM_HDLCPPP_ML_2 ) )


text:
MDM_GEN_PROTOCOLINFO( MDM_PROTOCOLID_HDLCPPP, MDM_GEN_HDLCPPP_PROTOCOL_DATA ( MDM_HDLCPPP_SPEED_56K, MDM_HDLCPPP_AUTH_CHAP, MDM_HDLCPPP_ML_2 ) )


text:
MDM_GEN_PROTOCOLINFO( MDM_PROTOCOLID_HDLCPPP, MDM_GEN_HDLCPPP_PROTOCOL_DATA ( MDM_HDLCPPP_SPEED_56K, MDM_HDLCPPP_AUTH_MSCHAP, MDM_HDLCPPP_ML_2 ) )


text:
MDM_GEN_PROTOCOLINFO( MDM_PROTOCOLID_HDLCPPP, MDM_GEN_HDLCPPP_PROTOCOL_DATA ( MDM_HDLCPPP_SPEED_64K, MDM_HDLCPPP_AUTH_DEFAULT, MDM_HDLCPPP_ML_2 ) )


text:
MDM_GEN_PROTOCOLINFO( MDM_PROTOCOLID_HDLCPPP, MDM_GEN_HDLCPPP_PROTOCOL_DATA ( MDM_HDLCPPP_SPEED_64K, MDM_HDLCPPP_AUTH_PAP, MDM_HDLCPPP_ML_2 ) )


text:
MDM_GEN_PROTOCOLINFO( MDM_PROTOCOLID_HDLCPPP, MDM_GEN_HDLCPPP_PROTOCOL_DATA ( MDM_HDLCPPP_SPEED_64K, MDM_HDLCPPP_AUTH_CHAP, MDM_HDLCPPP_ML_2 ) )


text:
MDM_GEN_PROTOCOLINFO( MDM_PROTOCOLID_HDLCPPP, MDM_GEN_HDLCPPP_PROTOCOL_DATA ( MDM_HDLCPPP_SPEED_64K, MDM_HDLCPPP_AUTH_MSCHAP, MDM_HDLCPPP_ML_2 ) )


text:
((((_speed)<<MDM_SHIFT_V120_SPEED)&MDM_MASK_V120_SPEED) |(((_ml )<<MDM_SHIFT_V120_ML )&MDM_MASK_V120_ML ))


text:
MDM_GEN_PROTOCOLINFO( MDM_PROTOCOLID_V120, MDM_GEN_V120_PROTOCOL_DATA ( MDM_V120_SPEED_64K, MDM_V120_ML_NONE ) )


text:
MDM_GEN_PROTOCOLINFO( MDM_PROTOCOLID_V120, MDM_GEN_V120_PROTOCOL_DATA ( MDM_V120_SPEED_56K, MDM_V120_ML_NONE ) )


text:
MDM_GEN_PROTOCOLINFO( MDM_PROTOCOLID_V120, MDM_GEN_V120_PROTOCOL_DATA ( MDM_V120_SPEED_56K, MDM_V120_ML_2 ) )


text:
MDM_GEN_PROTOCOLINFO( MDM_PROTOCOLID_V120, MDM_GEN_V120_PROTOCOL_DATA ( MDM_V120_SPEED_64K, MDM_V120_ML_2 ) )


text:
((((_speed)<<MDM_SHIFT_AUTO_SPEED)&MDM_MASK_AUTO_SPEED) |(((_ml )<<MDM_SHIFT_AUTO_ML )&MDM_MASK_AUTO_ML))


text:
MDM_GEN_PROTOCOLINFO( MDM_PROTOCOLID_AUTO, MDM_GEN_AUTO_PROTOCOL_DATA ( MDM_AUTO_SPEED_DEFAULT, MDM_AUTO_ML_NONE ) )


text:
MDM_GEN_PROTOCOLINFO( MDM_PROTOCOLID_AUTO, MDM_GEN_AUTO_PROTOCOL_DATA ( MDM_AUTO_SPEED_DEFAULT, MDM_AUTO_ML_2 ) )


text:
(D3DCS_LEFT | D3DCS_RIGHT | D3DCS_TOP | D3DCS_BOTTOM | D3DCS_FRONT | D3DCS_BACK | D3DCS_PLANE0 | D3DCS_PLANE1 | D3DCS_PLANE2 | D3DCS_PLANE3 | D3DCS_PLANE4 | D3DCS_PLANE5)


text:
( (0 << (D3DSP_SWIZZLE_SHIFT + 0)) | (1 << (D3DSP_SWIZZLE_SHIFT + 2)) | (2 << (D3DSP_SWIZZLE_SHIFT + 4)) | (3 << (D3DSP_SWIZZLE_SHIFT + 6)) )


text:
( (0 << (D3DSP_SWIZZLE_SHIFT + 0)) | (0 << (D3DSP_SWIZZLE_SHIFT + 2)) | (0 << (D3DSP_SWIZZLE_SHIFT + 4)) | (0 << (D3DSP_SWIZZLE_SHIFT + 6)) )


text:
( (1 << (D3DSP_SWIZZLE_SHIFT + 0)) | (1 << (D3DSP_SWIZZLE_SHIFT + 2)) | (1 << (D3DSP_SWIZZLE_SHIFT + 4)) | (1 << (D3DSP_SWIZZLE_SHIFT + 6)) )


text:
( (2 << (D3DSP_SWIZZLE_SHIFT + 0)) | (2 << (D3DSP_SWIZZLE_SHIFT + 2)) | (2 << (D3DSP_SWIZZLE_SHIFT + 4)) | (2 << (D3DSP_SWIZZLE_SHIFT + 6)) )


text:
( (3 << (D3DSP_SWIZZLE_SHIFT + 0)) | (3 << (D3DSP_SWIZZLE_SHIFT + 2)) | (3 << (D3DSP_SWIZZLE_SHIFT + 4)) | (3 << (D3DSP_SWIZZLE_SHIFT + 6)) )


text:
(( (msg) == WM_CTLCOLORMSGBOX || (msg) == WM_CTLCOLOREDIT || (msg) == WM_CTLCOLORLISTBOX || (msg) == WM_CTLCOLORBTN || (msg) == WM_CTLCOLORDLG || (msg) == WM_CTLCOLORSCROLLBAR || (msg) == WM_CTLCOLORSTATIC || (msg) == WM_COMPAREITEM || (msg) == WM_VKEYTOITEM || (msg) == WM_CHARTOITEM || (msg) == WM_QUERYDRAGICON || (msg) == WM_INITDIALOG ) ? (BOOL)(result) : (SetWindowLongPtr((hwnd), DWLP_MSGRESULT, (LPARAM)(LRESULT)(result)), TRUE))


text:
(UINT)(DWORD)(fn)((hwnd), WM_NCCALCSIZE, (WPARAM)(fCalcValidRects), (LPARAM)(NCCALCSIZE_PARAMS *)(lpcsp))


text:
(void)(fn)((hwnd), (fDoubleClick) ? WM_LBUTTONDBLCLK : WM_LBUTTONDOWN, (WPARAM)(UINT)(keyFlags), MAKELPARAM((x), (y)))


text:
(void)(fn)((hwnd), (fDoubleClick) ? WM_RBUTTONDBLCLK : WM_RBUTTONDOWN, (WPARAM)(UINT)(keyFlags), MAKELPARAM((x), (y)))


text:
(void)(fn)((hwnd), (fDoubleClick) ? WM_MBUTTONDBLCLK : WM_MBUTTONDOWN, (WPARAM)(UINT)(keyFlags), MAKELPARAM((x), (y)))


text:
((fn)((hwnd), (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), (int)(short)HIWORD(wParam), (UINT)(short)LOWORD(wParam)), 0L)


text:
(void)(fn)((hwnd), (fDoubleClick) ? WM_NCLBUTTONDBLCLK : WM_NCLBUTTONDOWN, (WPARAM)(UINT)(codeHitTest), MAKELPARAM((x), (y)))


text:
(void)(fn)((hwnd), (fDoubleClick) ? WM_NCRBUTTONDBLCLK : WM_NCRBUTTONDOWN, (WPARAM)(UINT)(codeHitTest), MAKELPARAM((x), (y)) )


text:
(void)(fn)((hwnd), (fDoubleClick) ? WM_NCMBUTTONDBLCLK : WM_NCMBUTTONDOWN, (WPARAM)(UINT)(codeHitTest), MAKELPARAM((x), (y)) )


text:
(int)(DWORD)(fn)((hwnd), WM_MOUSEACTIVATE, (WPARAM)(HWND)(hwndTopLevel), MAKELPARAM((codeHitTest), (msg)))


text:
((fn)((hwnd), (HMENU)(lParam), (HIWORD(wParam) & MF_POPUP) ? 0L : (int)(LOWORD(wParam)), (HIWORD(wParam) & MF_POPUP) ? GetSubMenu((HMENU)lParam, LOWORD(wParam)) : 0L, (UINT)(((short)HIWORD(wParam) == -1) ? 0xFFFFFFFF : HIWORD(wParam))), 0L)


text:
(void)(fn)((hwnd), WM_MENUSELECT, MAKEWPARAM((item), (flags)), (LPARAM)(HMENU)((hmenu) ? (hmenu) : (hmenuPopup)))


text:
(void)(fn)((hwnd), WM_HSCROLL, MAKEWPARAM((UINT)(int)(code),(UINT)(int)(pos)), (LPARAM)(HWND)(hwndCtl))


text:
(void)(fn)((hwnd), WM_VSCROLL, MAKEWPARAM((UINT)(int)(code), (UINT)(int)(pos)), (LPARAM)(HWND)(hwndCtl))


text:
((fn)((hwnd), (HWND)(wParam), (const LPPAINTSTRUCT)GlobalLock((HGLOBAL)(lParam))), GlobalUnlock((HGLOBAL)(lParam)), 0L)


text:
(void)(fn)((hwnd), WM_PAINTCLIPBOARD, (WPARAM)(HWND)(hwndCBViewer), (LPARAM)(LPPAINTSTRUCT)(lpPaintStruct))


text:
((fn)((hwnd), (HWND)(wParam), (const LPRECT)GlobalLock((HGLOBAL)(lParam))), GlobalUnlock((HGLOBAL)(lParam)), 0L)


text:
(BOOL)(DWORD)(fn)((hwnd), WM_SETCURSOR, (WPARAM)(HWND)(hwndCursor), MAKELPARAM((codeHitTest), (msg)))


text:
(HMENU)(UINT_PTR)(fn)((hwnd), WM_MDISETMENU, (WPARAM)((fRefresh) ? (hmenuFrame) : 0), (LPARAM)(hmenuWindow))


text:
(void)(fn)((hwnd), WM_DRAWITEM, (WPARAM)(((const DRAWITEMSTRUCT *)lpDrawItem)->CtlID), (LPARAM)(const DRAWITEMSTRUCT *)(lpDrawItem))


text:
(void)(fn)((hwnd), WM_MEASUREITEM, (WPARAM)(((MEASUREITEMSTRUCT *)lpMeasureItem)->CtlID), (LPARAM)(MEASUREITEMSTRUCT *)(lpMeasureItem))


text:
(void)(fn)((hwnd), WM_DELETEITEM, (WPARAM)(((const DELETEITEMSTRUCT *)(lpDeleteItem))->CtlID), (LPARAM)(const DELETEITEMSTRUCT *)(lpDeleteItem))


text:
(int)(DWORD)(fn)((hwnd), WM_COMPAREITEM, (WPARAM)(((const COMPAREITEMSTRUCT *)(lpCompareItem))->CtlID), (LPARAM)(const COMPAREITEMSTRUCT *)(lpCompareItem))


text:
(int)(DWORD)(fn)((hwnd), WM_CHARTOITEM, MAKEWPARAM((UINT)(ch), (UINT)(iCaret)), (LPARAM)(hwndListBox))


text:
(void)(fn)((hwnd), WM_DISPLAYCHANGE, (WPARAM)(UINT)(bitsPerPixel), (LPARAM)MAKELPARAM((UINT)(cxScreen), (UINT)(cyScreen)))


text:
(void)(fn)((hwnd), WM_CONTEXTMENU, (WPARAM)(HWND)(hwndContext), MAKELPARAM((UINT)(xPos), (UINT)(yPos)))


text:
((void)SNDMSG((hwndCtl), BM_SETSTYLE, (WPARAM)LOWORD(style), MAKELPARAM(((fRedraw) ? TRUE : FALSE), 0)))


text:
((*((int *)(lpch)) = (cchMax)), ((int)(DWORD)SNDMSG((hwndCtl), EM_GETLINE, (WPARAM)(int)(line), (LPARAM)(LPTSTR)(lpch))))


text:
((*((WORD *)(lpch)) = (cchMax)), ((int)(DWORD)SNDMSG((hwndCtl), EM_GETLINE, (WPARAM)(int)(line), (LPARAM)(LPTSTR)(lpch))))


text:
((int)(DWORD)SNDMSG((hwndCtl), LB_FINDSTRING, (WPARAM)(int)(indexStart), (LPARAM)(LPCTSTR)(lpszFind)))


text:
((int)(DWORD)SNDMSG((hwndCtl), LB_SELITEMRANGE, (WPARAM)(BOOL)(fSelect), MAKELPARAM((first), (last))))


text:
((int)(DWORD)SNDMSG((hwndCtl), LB_SELECTSTRING, (WPARAM)(int)(indexStart), (LPARAM)(LPCTSTR)(lpszFind)))


text:
((int)(DWORD)SNDMSG((hwndCtl), LB_FINDSTRINGEXACT, (WPARAM)(int)(indexStart), (LPARAM)(LPCTSTR)(lpszFind)))


text:
((int)(DWORD)SNDMSG((hwndCtl), CB_FINDSTRING, (WPARAM)(int)(indexStart), (LPARAM)(LPCTSTR)(lpszFind)))


text:
((int)(DWORD)SNDMSG((hwndCtl), CB_SELECTSTRING, (WPARAM)(int)(indexStart), (LPARAM)(LPCTSTR)(lpszSelect)))


text:
((int)(DWORD)SNDMSG((hwndCtl), CB_FINDSTRINGEXACT, (WPARAM)(int)(indexStart), (LPARAM)(LPCTSTR)(lpszFind)))


text:
( DDSCAPS2_CUBEMAP_POSITIVEX | DDSCAPS2_CUBEMAP_NEGATIVEX | DDSCAPS2_CUBEMAP_POSITIVEY | DDSCAPS2_CUBEMAP_NEGATIVEY | DDSCAPS2_CUBEMAP_POSITIVEZ | DDSCAPS2_CUBEMAP_NEGATIVEZ )


text:
(0x000000FF | STRSAFE_IGNORE_NULLS | STRSAFE_FILL_BEHIND_NULL | STRSAFE_FILL_ON_FAILURE | STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION)


text:
( (This)->lpVtbl -> RegisterPin(This,Filter,Name,bRendered,bOutput,bZero,bMany,ConnectsToFilter,ConnectsToPin) )


text:
( (This)->lpVtbl -> EnumMatchingFilters(This,ppEnum,dwMerit,bInputNeeded,clsInMaj,clsInSub,bRender,bOututNeeded,clsOutMaj,clsOutSub) )


text:
( (This)->lpVtbl -> RegisterFilter(This,clsidFilter,Name,ppMoniker,pclsidCategory,szInstance,prf2) )


text:
( (This)->lpVtbl -> EnumMatchingFilters(This,ppEnum,dwFlags,bExactMatch,dwMerit,bInputNeeded,cInputTypes,pInputTypes,pMedIn,pPinCategoryIn,bRender,bOutputNeeded,cOutputTypes,pOutputTypes,pMedOut,pPinCategoryOut) )


text:
( (This)->lpVtbl -> ControlStream(This,pCategory,pType,pFilter,pstart,pstop,wStartCookie,wStopCookie) )


text:
( (This)->lpVtbl -> GetInfo(This,pszVersion,pcbVersion,pszDescription,pcbDescription,pDefaultKeyFrameRate,pDefaultPFramesPerKey,pDefaultQuality,pCapabilities) )


text:
= ((((((AnalogVideo_NTSC_M|AnalogVideo_NTSC_M_J)|AnalogVideo_NTSC_433)|AnalogVideo_PAL_M)|AnalogVideo_PAL_N)|AnalogVideo_PAL_60)|AnalogVideo_PAL_N_COMBO)


text:
= (((((((AnalogVideo_SECAM_B|AnalogVideo_SECAM_D)|AnalogVideo_SECAM_G)|AnalogVideo_SECAM_H)|AnalogVideo_SECAM_K)|AnalogVideo_SECAM_K1)|AnalogVideo_SECAM_L)|AnalogVideo_SECAM_L1)


text:
( (This)->lpVtbl -> Set(This,guidPropSet,dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData) )


text:
( (This)->lpVtbl -> Get(This,guidPropSet,dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData,pcbReturned) )


text:
( (This)->lpVtbl -> GetInfo(This,pdwcbTotalFree,pdwcbLargestFree,pdwcbTotalMemory,pdwcbMinimumChunk) )


text:
( (This)->lpVtbl -> MapStreamId(This,ulStreamId,MediaSampleContent,ulSubstreamFilterValue,iDataOffset) )


text:
( (This)->lpVtbl -> SetAllSettingsWithNotify(This,__MIDL__ICodecAPI0002,ChangedParam,ChangedParamCount) )


text:
( (This)->lpVtbl -> GetDVDTextLanguageInfo(This,ulLangIndex,pulNumOfStrings,pLangCode,pbCharacterSet) )


text:
( (This)->lpVtbl -> GetDVDTextStringAsNative(This,ulLangIndex,ulStringIndex,pbBuffer,ulMaxBufferSize,pulActualSize,pType) )


text:
( (This)->lpVtbl -> GetDVDTextStringAsUnicode(This,ulLangIndex,ulStringIndex,pchwBuffer,ulMaxBufferSize,pulActualSize,pType) )


text:
( (This)->lpVtbl -> GetNativeVideoProps(This,pdwVideoWidth,pdwVideoHeight,pdwPictAspectRatioX,pdwPictAspectRatioY) )


text:
( (This)->lpVtbl -> OnUpdateOverlay(This,bBefore,dwFlags,bOldVisible,prcOldSrc,prcOldDest,bNewVisible,prcNewSrc,prcNewDest) )


text:
( (This)->lpVtbl -> Reconnect(This,pOutputPin,pInputPin,pmtFirstConnection,pUsingFilter,hAbortEvent,dwFlags) )


text:
( (This)->lpVtbl -> GetNumberOfDeinterlaceModes(This,lpVideoDescription,lpdwNumDeinterlaceModes,lpDeinterlaceModes) )


text:
( (This)->lpVtbl -> GetDeinterlaceModeCaps(This,lpDeinterlaceMode,lpVideoDescription,lpDeinterlaceCaps) )


text:
( (This)->lpVtbl -> CompositeImage(This,pD3DDevice,pddsRenderTarget,pmtRenderTarget,rtStart,rtEnd,dwClrBkGnd,pVideoStreamInfo,cStreams) )


text:
(((pbmi1)->dwBitMasks[iRED] == (pbmi2)->dwBitMasks[iRED]) && ((pbmi1)->dwBitMasks[iGREEN] == (pbmi2)->dwBitMasks[iGREEN]) && ((pbmi1)->dwBitMasks[iBLUE] == (pbmi2)->dwBitMasks[iBLUE]))


text:
( (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) )


text:
( (This)->lpVtbl -> InvokeAtStreamTime(This,pCmd,time,iid,dispidMethod,wFlags,cArgs,pDispParams,pvarResult,puArgErr) )


text:
( (This)->lpVtbl -> InvokeAtPresentationTime(This,pCmd,time,iid,dispidMethod,wFlags,cArgs,pDispParams,pvarResult,puArgErr) )


text:
( ((mt).subtype == MEDIASUBTYPE_ARGB4444) || ((mt).subtype == MEDIASUBTYPE_ARGB32) || ((mt).subtype == MEDIASUBTYPE_AYUV) || ((mt).subtype == MEDIASUBTYPE_AI44) || ((mt).subtype == MEDIASUBTYPE_IA44) || ((mt).subtype == MEDIASUBTYPE_ARGB1555) || ((mt).subtype == MEDIASUBTYPE_ARGB32_D3D_DX7_RT) || ((mt).subtype == MEDIASUBTYPE_ARGB4444_D3D_DX7_RT) || ((mt).subtype == MEDIASUBTYPE_ARGB1555_D3D_DX7_RT) || ((mt).subtype == MEDIASUBTYPE_ARGB32_D3D_DX9_RT) || ((mt).subtype == MEDIASUBTYPE_ARGB4444_D3D_DX9_RT) || ((mt).subtype == MEDIASUBTYPE_ARGB1555_D3D_DX9_RT) )


text:
(((mt).subtype == MEDIASUBTYPE_ARGB32_D3D_DX7_RT) || ((mt).subtype == MEDIASUBTYPE_ARGB4444_D3D_DX7_RT) || ((mt).subtype == MEDIASUBTYPE_ARGB1555_D3D_DX7_RT) )


text:
(((mt).subtype == MEDIASUBTYPE_ARGB32_D3D_DX7_RT) || ((mt).subtype == MEDIASUBTYPE_ARGB4444_D3D_DX7_RT) || ((mt).subtype == MEDIASUBTYPE_ARGB1555_D3D_DX7_RT) || ((mt).subtype == MEDIASUBTYPE_RGB32_D3D_DX7_RT) || ((mt).subtype == MEDIASUBTYPE_RGB16_D3D_DX7_RT))


text:
(((mt).subtype == MEDIASUBTYPE_ARGB32_D3D_DX9_RT) || ((mt).subtype == MEDIASUBTYPE_ARGB4444_D3D_DX9_RT) || ((mt).subtype == MEDIASUBTYPE_ARGB1555_D3D_DX9_RT) )


text:
(((mt).subtype == MEDIASUBTYPE_ARGB32_D3D_DX9_RT) || ((mt).subtype == MEDIASUBTYPE_ARGB4444_D3D_DX9_RT) || ((mt).subtype == MEDIASUBTYPE_ARGB1555_D3D_DX9_RT) || ((mt).subtype == MEDIASUBTYPE_RGB32_D3D_DX9_RT) || ((mt).subtype == MEDIASUBTYPE_RGB16_D3D_DX9_RT))


text:
{ NDRcopy ( (((char *)(Target))+(LowerIndex)), (Source)->Buffer, (unsigned int)((UpperIndex)-(LowerIndex))); *(unsigned long *)&(Source)->Buffer += ((UpperIndex)-(LowerIndex)); }


text:
(_midl_ma4( p, unsigned long) = s, _midl_ma4( p, unsigned long) = 0, _midl_ma4( p, unsigned long) = l)


text:
(unsigned char)(s & 0xff), (unsigned char)((s & 0x0000ff00) >> 8), (unsigned char)((s & 0x00ff0000) >> 16), (unsigned char)(s >> 24)


text:
( (RpcExceptionCode() == STATUS_ACCESS_VIOLATION) || (RpcExceptionCode() == STATUS_DATATYPE_MISALIGNMENT) || (RpcExceptionCode() == RPC_X_BAD_STUB_DATA) || (RpcExceptionCode() == RPC_S_INVALID_BOUND) )


text:
= (MFVideoChromaSubsampling_Horizontally_Cosited|MFVideoChromaSubsampling_Vertically_AlignedChromaPlanes)


text:
= ((MFVideoChromaSubsampling_Horizontally_Cosited|MFVideoChromaSubsampling_Vertically_Cosited)|MFVideoChromaSubsampling_Vertically_AlignedChromaPlanes)


text:
( (This)->lpVtbl -> GetStreamLimits(This,pdwInputMinimum,pdwInputMaximum,pdwOutputMinimum,pdwOutputMaximum) )


text:
( (This)->lpVtbl -> GetStreamIDs(This,dwInputIDArraySize,pdwInputIDs,dwOutputIDArraySize,pdwOutputIDs) )


text:
( (This)->lpVtbl -> MapOutputCoordinateToInputStream(This,xOut,yOut,dwOutputStreamIndex,dwInputStreamIndex,pxIn,pyIn) )


text:
= (DXVA2_VideoChromaSubsampling_Horizontally_Cosited|DXVA2_VideoChromaSubsampling_Vertically_AlignedChromaPlanes)


text:
= (DXVA2_VideoChromaSubsampling_Horizontally_Cosited|DXVA2_VideoChromaSubsampling_Vertically_Cosited)


text:
= ((DXVA2_VideoChromaSubsampling_Horizontally_Cosited|DXVA2_VideoChromaSubsampling_Vertically_Cosited)|DXVA2_VideoChromaSubsampling_Vertically_AlignedChromaPlanes)


text:
( (This)->lpVtbl -> CreateSurface(This,Width,Height,BackBuffers,Format,Pool,Usage,DxvaType,ppSurface,pSharedHandle) )


text:
( (This)->lpVtbl -> CreateVideoDecoder(This,Guid,pVideoDesc,pConfig,ppDecoderRenderTargets,NumRenderTargets,ppDecode) )


text:
( (This)->lpVtbl -> GetVideoProcessorRenderTargets(This,VideoProcDeviceGuid,pVideoDesc,pCount,pFormats) )


text:
( (This)->lpVtbl -> GetVideoProcessorSubStreamFormats(This,VideoProcDeviceGuid,pVideoDesc,RenderTargetFormat,pCount,pFormats) )


text:
( (This)->lpVtbl -> GetVideoProcessorCaps(This,VideoProcDeviceGuid,pVideoDesc,RenderTargetFormat,pCaps) )


text:
( (This)->lpVtbl -> GetProcAmpRange(This,VideoProcDeviceGuid,pVideoDesc,RenderTargetFormat,ProcAmpCap,pRange) )


text:
( (This)->lpVtbl -> GetFilterPropertyRange(This,VideoProcDeviceGuid,pVideoDesc,RenderTargetFormat,FilterSetting,pRange) )


text:
( (This)->lpVtbl -> CreateVideoProcessor(This,VideoProcDeviceGuid,pVideoDesc,RenderTargetFormat,MaxNumSubStreams,ppVidProcess) )


text:
( (This)->lpVtbl -> GetCreationParameters(This,pDeviceGuid,pVideoDesc,pConfig,pDecoderRenderTargets,pNumSurfaces) )


text:
( (This)->lpVtbl -> GetCreationParameters(This,pDeviceGuid,pVideoDesc,pRenderTargetFormat,pMaxNumSubStreams) )


text:
( (This)->lpVtbl -> VideoProcessBlt(This,pRenderTarget,pBltParams,pSamples,NumSamples,pHandleComplete) )


text:
(CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER | CLSCTX_INPROC_SERVER16 | CLSCTX_REMOTE_SERVER | CLSCTX_NO_CODE_DOWNLOAD | CLSCTX_NO_CUSTOM_MARSHAL | CLSCTX_ENABLE_CODE_DOWNLOAD | CLSCTX_NO_FAILURE_LOG | CLSCTX_DISABLE_AAA | CLSCTX_ENABLE_AAA | CLSCTX_FROM_DEFAULT_CONTEXT | CLSCTX_ACTIVATE_32_BIT_SERVER | CLSCTX_ACTIVATE_64_BIT_SERVER | CLSCTX_ENABLE_CLOAKING | CLSCTX_PS_DLL)


text:
(DTBG_CLIPRECT | DTBG_DRAWSOLID | DTBG_OMITBORDER | DTBG_OMITCONTENT | DTBG_COMPUTINGREGION | DTBG_MIRRORDC | DTBG_NOMIRROR)


text:
(HTTB_RESIZINGBORDER_LEFT | HTTB_RESIZINGBORDER_TOP | HTTB_RESIZINGBORDER_RIGHT | HTTB_RESIZINGBORDER_BOTTOM)


text:
(DTT_TEXTCOLOR | DTT_BORDERCOLOR | DTT_SHADOWCOLOR | DTT_SHADOWTYPE | DTT_SHADOWOFFSET | DTT_BORDERSIZE | DTT_FONTPROP | DTT_COLORPROP | DTT_STATEID | DTT_CALCRECT | DTT_APPLYOVERLAY | DTT_GLOWSIZE | DTT_COMPOSITED)


text:
(CFM_EFFECTS | CFM_DISABLED | CFM_SMALLCAPS | CFM_ALLCAPS | CFM_HIDDEN | CFM_OUTLINE | CFM_SHADOW | CFM_EMBOSS | CFM_IMPRINT | CFM_DISABLED | CFM_REVISED | CFM_SUBSCRIPT | CFM_SUPERSCRIPT | CFM_BACKCOLOR)


text:
(CFM_ALL | CFM_EFFECTS2 | CFM_BACKCOLOR | CFM_LCID | CFM_UNDERLINETYPE | CFM_WEIGHT | CFM_REVAUTHOR | CFM_SPACING | CFM_KERNING | CFM_STYLE | CFM_ANIMATION)


text:
(PFM_STARTINDENT | PFM_RIGHTINDENT | PFM_OFFSET | PFM_ALIGNMENT | PFM_TABSTOPS | PFM_NUMBERING | PFM_OFFSETINDENT| PFM_RTLPARA)


text:
(PFM_RTLPARA | PFM_KEEP | PFM_KEEPNEXT | PFM_TABLE | PFM_PAGEBREAKBEFORE | PFM_NOLINENUMBER | PFM_NOWIDOWCONTROL | PFM_DONOTHYPHEN | PFM_SIDEBYSIDE | PFM_TABLE | PFM_TABLEROWDELIMITER)


text:
(PFM_ALL | PFM_EFFECTS | PFM_SPACEBEFORE | PFM_SPACEAFTER | PFM_LINESPACING | PFM_STYLE | PFM_SHADING | PFM_BORDER | PFM_NUMBERINGTAB | PFM_NUMBERINGSTART | PFM_NUMBERINGSTYLE)


text:
((header)->layer == MAD_LAYER_I ? 12 : (((header)->layer == MAD_LAYER_III && ((header)->flags & MAD_FLAG_LSF_EXT)) ? 18 : 36))


text:
do { int __atl_condVal=!!(expr); ATLASSUME(__atl_condVal); if(!(__atl_condVal)) AtlThrow(hr); } __pragma(warning(suppress:4127)) while (0)


text:
do { HRESULT __atl_hresult = (hrExpr); ATLENSURE_THROW(SUCCEEDED(__atl_hresult), __atl_hresult); } __pragma(warning(suppress:4127)) while (0)


text:
do { int __atl_condVal=!!(expr); ATLASSERT(__atl_condVal); if(!(__atl_condVal)) return val; } __pragma(warning(suppress:4127)) while (0)


text:
do { errno_t _saveErrno = errno; errno = 0; (expr); if(0 != errno) { AtlCrtErrorCheck(errno); } else { errno = _saveErrno; } } __pragma(warning(suppress:4127)) while (0)


text:
__pragma(warning(push)) __pragma(warning(disable: 4571)) try{x;} catch(...) {} __pragma(warning(pop))


text:
static LPCOLESTR GetAppId() throw() { return OLESTR(appid); } static const TCHAR* GetAppIdT() throw() { return _T(appid); } static HRESULT WINAPI UpdateRegistryAppId(_In_ BOOL bRegister) throw() { ATL::_ATL_REGMAP_ENTRY aMapEntries [] = { { OLESTR("APPID"), GetAppId() }, { NULL, NULL } }; return ATL::_pAtlModule->UpdateRegistryFromResource(resid, bRegister, aMapEntries); }


text:
UrlCanonicalize(pszUrl, pszEscaped, pcchEscaped, URL_ESCAPE_SPACES_ONLY |URL_DONT_ESCAPE_EXTRA_INFO )


text:
(((ULONGLONG)(major) << 48) | ((ULONGLONG)(minor) << 32) | ((ULONGLONG)(build) << 16) | ((ULONGLONG)( qfe) << 0))


text:
EXTERN_C const PROPERTYKEY DECLSPEC_SELECTANY name = { { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }, pid }


text:
_CRT_DEPRECATE_TEXT("Direct floating point control is not supported or reliable from within managed code. ")


text:
(_RC_NEAR + _PC_53 + _EM_INVALID + _EM_ZERODIVIDE + _EM_OVERFLOW + _EM_UNDERFLOW + _EM_INEXACT + _EM_DENORMAL)


text:
(_RC_NEAR + _EM_INVALID + _EM_ZERODIVIDE + _EM_OVERFLOW + _EM_UNDERFLOW + _EM_INEXACT + _EM_DENORMAL)


text:
_SAL2_Source_(_In_, (), _Pre1_impl_(__notnull_impl_notref) _Pre_valid_impl_ _Deref_pre1_impl_(__readaccess_impl_notref))


text:
_SAL2_Source_(_In_opt_, (), _Pre1_impl_(__maybenull_impl_notref) _Pre_valid_impl_ _Deref_pre_readonly_)


text:
_SAL2_Source_(_In_reads_or_z_, (size), _In_ _When_(_String_length_(_Curr_) < (size), _Pre_z_) _When_(_String_length_(_Curr_) >= (size), _Pre1_impl_(__count_impl(size))))


text:
_SAL2_Source_(_In_reads_or_z_opt_, (size), _In_opt_ _When_(_String_length_(_Curr_) < (size), _Pre_z_) _When_(_String_length_(_Curr_) >= (size), _Pre1_impl_(__count_impl(size))))


text:
_SAL2_Source_(_In_reads_to_ptr_opt_z_, (ptr), _Pre_opt_ptrdiff_count_(ptr) _Deref_pre_readonly_ _Pre_opt_z_)


text:
_SAL2_Source_(_Out_writes_to_opt_, (size,count), _Pre_opt_cap_(size) _Post_valid_impl_ _Post_count_(count))


text:
_SAL2_Source_(_Out_writes_bytes_to_, (size,count), _Pre_bytecap_(size) _Post_valid_impl_ _Post_bytecount_(count))


text:
_SAL2_Source_(_Out_writes_bytes_to_opt_, (size,count), _Pre_opt_bytecap_(size) _Post_valid_impl_ _Post_bytecount_(count))


text:
_SAL2_Source_(_Out_writes_bytes_all_opt_, (size), _Out_writes_bytes_to_opt_(_Old_(size), _Old_(size)))


text:
_SAL2_Source_(_Out_writes_to_ptr_opt_z_, (ptr), _Pre_opt_ptrdiff_cap_(ptr) _Post_valid_impl_ Post_z_)


text:
_SAL2_Source_(_Inout_updates_z_, (size), _Pre_cap_(size) _Pre_valid_impl_ _Post_valid_impl_ _Pre1_impl_(__zterm_impl) _Post1_impl_(__zterm_impl))


text:
_SAL2_Source_(_Inout_updates_opt_z_, (size), _Pre_opt_cap_(size) _Pre_valid_impl_ _Post_valid_impl_ _Pre1_impl_(__zterm_impl) _Post1_impl_(__zterm_impl))


text:
_SAL2_Source_(_Inout_updates_to_, (size,count), _Out_writes_to_(size,count) _Pre_valid_impl_ _Pre1_impl_(__count_impl(size)))


text:
_SAL2_Source_(_Inout_updates_to_opt_, (size,count), _Out_writes_to_opt_(size,count) _Pre_valid_impl_ _Pre1_impl_(__count_impl(size)))


text:
_SAL2_Source_(_Inout_updates_bytes_, (size), _Pre_bytecap_(size) _Pre_valid_impl_ _Post_valid_impl_)


text:
_SAL2_Source_(_Inout_updates_bytes_opt_, (size), _Pre_opt_bytecap_(size) _Pre_valid_impl_ _Post_valid_impl_)


text:
_SAL2_Source_(_Inout_updates_bytes_to_, (size,count), _Out_writes_bytes_to_(size,count) _Pre_valid_impl_ _Pre1_impl_(__bytecount_impl(size)))


text:
_SAL2_Source_(_Inout_updates_bytes_to_opt_, (size,count), _Out_writes_bytes_to_opt_(size,count) _Pre_valid_impl_ _Pre1_impl_(__bytecount_impl(size)))


text:
_SAL2_Source_(_Inout_updates_bytes_all_, (size), _Inout_updates_bytes_to_(_Old_(size), _Old_(size)))


text:
_SAL2_Source_(_Inout_updates_bytes_all_opt_, (size), _Inout_updates_bytes_to_opt_(_Old_(size), _Old_(size)))


text:
_SAL2_Source_(_Outptr_result_maybenull_, (), _Out_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __count_impl(1)))


text:
_SAL2_Source_(_Outptr_opt_, (), _Out_opt_impl_ _Deref_post2_impl_(__notnull_impl_notref, __count_impl(1)))


text:
_SAL2_Source_(_Outptr_opt_result_maybenull_, (), _Out_opt_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __count_impl(1)))


text:
_SAL2_Source_(_COM_Outptr_result_maybenull_, (), _Outptr_result_maybenull_ _On_failure_(_Deref_post_null_))


text:
_SAL2_Source_(_COM_Outptr_opt_result_maybenull_, (), _Outptr_opt_result_maybenull_ _On_failure_(_Deref_post_null_))


text:
_SAL2_Source_(_Outptr_result_buffer_, (size), _Out_impl_ _Deref_post2_impl_(__notnull_impl_notref, __cap_impl(size)))


text:
_SAL2_Source_(_Outptr_opt_result_buffer_, (size), _Out_opt_impl_ _Deref_post2_impl_(__notnull_impl_notref, __cap_impl(size)))


text:
_SAL2_Source_(_Outptr_result_buffer_to_, (size, count), _Out_impl_ _Deref_post3_impl_(__notnull_impl_notref, __cap_impl(size), __count_impl(count)))


text:
_SAL2_Source_(_Outptr_opt_result_buffer_to_, (size, count), _Out_opt_impl_ _Deref_post3_impl_(__notnull_impl_notref, __cap_impl(size), __count_impl(count)))


text:
_SAL2_Source_(_Outptr_result_buffer_all_, (size), _Out_impl_ _Deref_post2_impl_(__notnull_impl_notref, __count_impl(size)))


text:
_SAL2_Source_(_Outptr_opt_result_buffer_all_, (size), _Out_opt_impl_ _Deref_post2_impl_(__notnull_impl_notref, __count_impl(size)))


text:
_SAL2_Source_(_Outptr_result_buffer_maybenull_, (size), _Out_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __cap_impl(size)))


text:
_SAL2_Source_(_Outptr_opt_result_buffer_maybenull_, (size), _Out_opt_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __cap_impl(size)))


text:
_SAL2_Source_(_Outptr_result_buffer_to_maybenull_, (size, count), _Out_impl_ _Deref_post3_impl_(__maybenull_impl_notref, __cap_impl(size), __count_impl(count)))


text:
_SAL2_Source_(_Outptr_opt_result_buffer_to_maybenull_, (size, count), _Out_opt_impl_ _Deref_post3_impl_(__maybenull_impl_notref, __cap_impl(size), __count_impl(count)))


text:
_SAL2_Source_(_Outptr_result_buffer_all_maybenull_, (size), _Out_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __count_impl(size)))


text:
_SAL2_Source_(_Outptr_opt_result_buffer_all_maybenull_, (size), _Out_opt_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __count_impl(size)))


text:
_SAL2_Source_(_Outptr_result_bytebuffer_, (size), _Out_impl_ _Deref_post2_impl_(__notnull_impl_notref, __bytecap_impl(size)))


text:
_SAL2_Source_(_Outptr_opt_result_bytebuffer_, (size), _Out_opt_impl_ _Deref_post2_impl_(__notnull_impl_notref, __bytecap_impl(size)))


text:
_SAL2_Source_(_Outptr_result_bytebuffer_to_, (size, count), _Out_impl_ _Deref_post3_impl_(__notnull_impl_notref, __bytecap_impl(size), __bytecount_impl(count)))


text:
_SAL2_Source_(_Outptr_opt_result_bytebuffer_to_, (size, count), _Out_opt_impl_ _Deref_post3_impl_(__notnull_impl_notref, __bytecap_impl(size), __bytecount_impl(count)))


text:
_SAL2_Source_(_Outptr_result_bytebuffer_all_, (size), _Out_impl_ _Deref_post2_impl_(__notnull_impl_notref, __bytecount_impl(size)))


text:
_SAL2_Source_(_Outptr_opt_result_bytebuffer_all_, (size), _Out_opt_impl_ _Deref_post2_impl_(__notnull_impl_notref, __bytecount_impl(size)))


text:
_SAL2_Source_(_Outptr_result_bytebuffer_maybenull_, (size), _Out_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __bytecap_impl(size)))


text:
_SAL2_Source_(_Outptr_opt_result_bytebuffer_maybenull_, (size), _Out_opt_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __bytecap_impl(size)))


text:
_SAL2_Source_(_Outptr_result_bytebuffer_to_maybenull_, (size, count), _Out_impl_ _Deref_post3_impl_(__maybenull_impl_notref, __bytecap_impl(size), __bytecount_impl(count)))


text:
_SAL2_Source_(_Outptr_opt_result_bytebuffer_to_maybenull_, (size, count), _Out_opt_impl_ _Deref_post3_impl_(__maybenull_impl_notref, __bytecap_impl(size), __bytecount_impl(count)))


text:
_SAL2_Source_(_Outptr_result_bytebuffer_all_maybenull_, (size), _Out_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __bytecount_impl(size)))


text:
_SAL2_Source_(_Outptr_opt_result_bytebuffer_all_maybenull_, (size), _Out_opt_impl_ _Deref_post2_impl_(__maybenull_impl_notref, __bytecount_impl(size)))


text:
_SAL2_Source_(_Outref_result_maybenull_, (), _Pre2_impl_(__notnull_impl_notref, __cap_c_one_notref_impl) _Post_maybenull_ _Post_valid_impl_)


text:
_SAL2_Source_(_Outref_result_buffer_to_, (size, count), _Outref_result_buffer_(size) _Post1_impl_(__count_impl(count)))


text:
_SAL2_Source_(_Outref_result_bytebuffer_to_, (size, count), _Outref_result_bytebuffer_(size) _Post1_impl_(__bytecount_impl(count)))


text:
_SAL2_Source_(_Outref_result_bytebuffer_all_, (size), _Outref_result_bytebuffer_to_(size, _Old_(size)))


text:
_SAL2_Source_(_Outref_result_buffer_maybenull_, (size), _Outref_result_maybenull_ _Post1_impl_(__cap_impl(size)))


text:
_SAL2_Source_(_Outref_result_bytebuffer_maybenull_, (size), _Outref_result_maybenull_ _Post1_impl_(__bytecap_impl(size)))


text:
_SAL2_Source_(_Outref_result_buffer_to_maybenull_, (size, count), _Outref_result_buffer_maybenull_(size) _Post1_impl_(__count_impl(count)))


text:
_SAL2_Source_(_Outref_result_bytebuffer_to_maybenull_, (size, count), _Outref_result_bytebuffer_maybenull_(size) _Post1_impl_(__bytecount_impl(count)))


text:
_SAL2_Source_(_Outref_result_buffer_all_maybenull_, (size), _Outref_result_buffer_to_maybenull_(size, _Old_(size)))


text:
_SAL2_Source_(_Outref_result_bytebuffer_all_maybenull_, (size), _Outref_result_bytebuffer_to_maybenull_(size, _Old_(size)))


text:
_SAL2_Source_(_Result_zeroonfailure_, (), _On_failure_(_Notref_impl_ _Deref_impl_ _Out_range_(==, 0)))


text:
_SAL2_Source_(_Ret_writes_, (size), _Ret2_impl_(__notnull_impl, __count_impl(size)) _Ret_valid_impl_)


text:
_SAL2_Source_(_Ret_writes_z_, (size), _Ret3_impl_(__notnull_impl, __count_impl(size), __zterm_impl) _Ret_valid_impl_)


text:
_SAL2_Source_(_Ret_writes_bytes_, (size), _Ret2_impl_(__notnull_impl, __bytecount_impl(size)) _Ret_valid_impl_)


text:
_SAL2_Source_(_Ret_writes_maybenull_, (size), _Ret2_impl_(__maybenull_impl,__count_impl(size)) _Ret_valid_impl_)


text:
_SAL2_Source_(_Ret_writes_maybenull_z_, (size), _Ret3_impl_(__maybenull_impl,__count_impl(size),__zterm_impl) _Ret_valid_impl_)


text:
_SAL2_Source_(_Ret_writes_bytes_maybenull_, (size), _Ret2_impl_(__maybenull_impl,__bytecount_impl(size)) _Ret_valid_impl_)


text:
_SAL2_Source_(_Ret_writes_to_, (size,count), _Ret3_impl_(__notnull_impl, __cap_impl(size), __count_impl(count)) _Ret_valid_impl_)


text:
_SAL2_Source_(_Ret_writes_bytes_to_, (size,count), _Ret3_impl_(__notnull_impl, __bytecap_impl(size), __bytecount_impl(count)) _Ret_valid_impl_)


text:
_SAL2_Source_(_Ret_writes_to_maybenull_, (size,count), _Ret3_impl_(__maybenull_impl, __cap_impl(size), __count_impl(count)) _Ret_valid_impl_)


text:
_SAL2_Source_(_Ret_writes_bytes_to_maybenull_, (size,count), _Ret3_impl_(__maybenull_impl, __bytecap_impl(size), __bytecount_impl(count)) _Ret_valid_impl_)


text:
_SAL2_Source_(_Field_size_part_, (size, count), _Notnull_ _Writable_elements_(size) _Readable_elements_(count))


text:
_SAL2_Source_(_Field_size_part_opt_, (size, count), _Maybenull_ _Writable_elements_(size) _Readable_elements_(count))


text:
_SAL2_Source_(_Field_size_bytes_part_, (size, count), _Notnull_ _Writable_bytes_(size) _Readable_bytes_(count))


text:
_SAL2_Source_(_Field_size_bytes_part_opt_, (size, count), _Maybenull_ _Writable_bytes_(size) _Readable_bytes_(count))


text:
_SAL2_Source_(_Pre_readable_byte_size_, (size), _Pre1_impl_(__bytecount_impl(size)) _Pre_valid_impl_)


text:
_SAL2_Source_(_Post_readable_byte_size_, (size), _Post1_impl_(__bytecount_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_In_opt_z_bytecount_, (size), _Pre_opt_z_ _Pre_opt_bytecount_(size) _Deref_pre_readonly_)


text:
_SAL1_1_Source_(_In_opt_z_count_c_, (size), _Pre_opt_z_ _Pre_opt_count_c_(size) _Deref_pre_readonly_)


text:
_SAL1_1_Source_(_In_opt_z_bytecount_c_, (size), _Pre_opt_z_ _Pre_opt_bytecount_c_(size) _Deref_pre_readonly_)


text:
_SAL1_1_Source_(_Out_opt_z_cap_m_, (mult,size), _Pre_opt_cap_m_(mult,size) _Post_valid_impl_ _Post_z_)


text:
_SAL1_1_Source_(_Out_opt_z_bytecap_c_, (size), _Pre_opt_bytecap_c_(size) _Post_valid_impl_ _Post_z_)


text:
_SAL1_1_Source_(_Out_opt_z_bytecap_x_, (size), _Pre_opt_bytecap_x_(size) _Post_valid_impl_ _Post_z_)


text:
_SAL1_1_Source_(_Out_cap_post_count_, (cap,count), _Pre_cap_(cap) _Post_valid_impl_ _Post_count_(count))


text:
_SAL1_1_Source_(_Out_opt_cap_post_count_, (cap,count), _Pre_opt_cap_(cap) _Post_valid_impl_ _Post_count_(count))


text:
_SAL1_1_Source_(_Out_bytecap_post_bytecount_, (cap,count), _Pre_bytecap_(cap) _Post_valid_impl_ _Post_bytecount_(count))


text:
_SAL1_1_Source_(_Out_opt_bytecap_post_bytecount_, (cap,count), _Pre_opt_bytecap_(cap) _Post_valid_impl_ _Post_bytecount_(count))


text:
_SAL1_1_Source_(_Out_z_cap_post_count_, (cap,count), _Pre_cap_(cap) _Post_valid_impl_ _Post_z_count_(count))


text:
_SAL1_1_Source_(_Out_opt_z_cap_post_count_, (cap,count), _Pre_opt_cap_(cap) _Post_valid_impl_ _Post_z_count_(count))


text:
_SAL1_1_Source_(_Out_z_bytecap_post_bytecount_, (cap,count), _Pre_bytecap_(cap) _Post_valid_impl_ _Post_z_bytecount_(count))


text:
_SAL1_1_Source_(_Out_opt_z_bytecap_post_bytecount_, (cap,count), _Pre_opt_bytecap_(cap) _Post_valid_impl_ _Post_z_bytecount_(count))


text:
_SAL1_1_Source_(_Out_capcount_, (capcount), _Pre_cap_(capcount) _Post_valid_impl_ _Post_count_(capcount))


text:
_SAL1_1_Source_(_Out_opt_capcount_, (capcount), _Pre_opt_cap_(capcount) _Post_valid_impl_ _Post_count_(capcount))


text:
_SAL1_1_Source_(_Out_bytecapcount_, (capcount), _Pre_bytecap_(capcount) _Post_valid_impl_ _Post_bytecount_(capcount))


text:
_SAL1_1_Source_(_Out_opt_bytecapcount_, (capcount), _Pre_opt_bytecap_(capcount) _Post_valid_impl_ _Post_bytecount_(capcount))


text:
_SAL1_1_Source_(_Out_capcount_x_, (capcount), _Pre_cap_x_(capcount) _Post_valid_impl_ _Post_count_x_(capcount))


text:
_SAL1_1_Source_(_Out_opt_capcount_x_, (capcount), _Pre_opt_cap_x_(capcount) _Post_valid_impl_ _Post_count_x_(capcount))


text:
_SAL1_1_Source_(_Out_bytecapcount_x_, (capcount), _Pre_bytecap_x_(capcount) _Post_valid_impl_ _Post_bytecount_x_(capcount))


text:
_SAL1_1_Source_(_Out_opt_bytecapcount_x_, (capcount), _Pre_opt_bytecap_x_(capcount) _Post_valid_impl_ _Post_bytecount_x_(capcount))


text:
_SAL1_1_Source_(_Out_z_capcount_, (capcount), _Pre_cap_(capcount) _Post_valid_impl_ _Post_z_count_(capcount))


text:
_SAL1_1_Source_(_Out_opt_z_capcount_, (capcount), _Pre_opt_cap_(capcount) _Post_valid_impl_ _Post_z_count_(capcount))


text:
_SAL1_1_Source_(_Out_z_bytecapcount_, (capcount), _Pre_bytecap_(capcount) _Post_valid_impl_ _Post_z_bytecount_(capcount))


text:
_SAL1_1_Source_(_Out_opt_z_bytecapcount_, (capcount), _Pre_opt_bytecap_(capcount) _Post_valid_impl_ _Post_z_bytecount_(capcount))


text:
_SAL1_1_Source_(_Deref_pre_z_, (), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__zterm_impl) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_z_, (), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__zterm_impl) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_cap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_impl(size)))


text:
_SAL1_1_Source_(_Deref_pre_opt_cap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_impl(size)))


text:
_SAL1_1_Source_(_Deref_pre_bytecap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_impl(size)))


text:
_SAL1_1_Source_(_Deref_pre_opt_bytecap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_impl(size)))


text:
_SAL1_1_Source_(_Deref_pre_cap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_c_impl(size)))


text:
_SAL1_1_Source_(_Deref_pre_opt_cap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_c_impl(size)))


text:
_SAL1_1_Source_(_Deref_pre_bytecap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_c_impl(size)))


text:
_SAL1_1_Source_(_Deref_pre_opt_bytecap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_c_impl(size)))


text:
_SAL1_1_Source_(_Deref_pre_cap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_x_impl(size)))


text:
_SAL1_1_Source_(_Deref_pre_opt_cap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_x_impl(size)))


text:
_SAL1_1_Source_(_Deref_pre_bytecap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_x_impl(size)))


text:
_SAL1_1_Source_(_Deref_pre_opt_bytecap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_x_impl(size)))


text:
_SAL1_1_Source_(_Deref_pre_z_cap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_z_cap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_z_bytecap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_z_bytecap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_z_cap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_z_cap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_z_bytecap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_z_bytecap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_z_cap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_z_cap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__cap_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_z_bytecap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_z_bytecap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_valid_cap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_valid_cap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_valid_bytecap_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_valid_bytecap_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_valid_cap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_valid_cap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_valid_bytecap_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_valid_bytecap_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_valid_cap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__cap_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_valid_cap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__cap_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_valid_bytecap_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecap_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_valid_bytecap_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecap_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_count_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__count_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_count_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__count_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_bytecount_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecount_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_bytecount_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecount_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_count_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__count_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_count_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__count_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_bytecount_c_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecount_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_bytecount_c_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecount_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_count_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__count_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_count_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__count_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_bytecount_x_, (size), _Deref_pre1_impl_(__notnull_impl_notref) _Deref_pre1_impl_(__bytecount_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_bytecount_x_, (size), _Deref_pre1_impl_(__maybenull_impl_notref) _Deref_pre1_impl_(__bytecount_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_pre_opt_valid_, (), _Deref_pre1_impl_(__maybenull_impl_notref) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_z_, (), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__zterm_impl) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_z_, (), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__zterm_impl) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_cap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_impl(size)))


text:
_SAL1_1_Source_(_Deref_post_opt_cap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_impl(size)))


text:
_SAL1_1_Source_(_Deref_post_bytecap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_impl(size)))


text:
_SAL1_1_Source_(_Deref_post_opt_bytecap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_impl(size)))


text:
_SAL1_1_Source_(_Deref_post_cap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_c_impl(size)))


text:
_SAL1_1_Source_(_Deref_post_opt_cap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_c_impl(size)))


text:
_SAL1_1_Source_(_Deref_post_bytecap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_c_impl(size)))


text:
_SAL1_1_Source_(_Deref_post_opt_bytecap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_c_impl(size)))


text:
_SAL1_1_Source_(_Deref_post_cap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_x_impl(size)))


text:
_SAL1_1_Source_(_Deref_post_opt_cap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_x_impl(size)))


text:
_SAL1_1_Source_(_Deref_post_bytecap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_x_impl(size)))


text:
_SAL1_1_Source_(_Deref_post_opt_bytecap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_x_impl(size)))


text:
_SAL1_1_Source_(_Deref_post_z_cap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_z_cap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_z_bytecap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_z_bytecap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_z_cap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_c_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_z_cap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_c_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_z_bytecap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_z_bytecap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_z_cap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_x_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_z_cap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__cap_x_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_z_bytecap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_z_bytecap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_valid_cap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_valid_cap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_valid_bytecap_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_valid_bytecap_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_valid_cap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_c_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_valid_cap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_c_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_valid_bytecap_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_c_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_valid_bytecap_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_c_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_valid_cap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__cap_x_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_valid_cap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__cap_x_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_valid_bytecap_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecap_x_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_valid_bytecap_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecap_x_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_count_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__count_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_count_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__count_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_bytecount_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecount_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_bytecount_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecount_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_count_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__count_c_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_count_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__count_c_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_bytecount_c_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecount_c_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_bytecount_c_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecount_c_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_count_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__count_x_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_count_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__count_x_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_bytecount_x_, (size), _Deref_post1_impl_(__notnull_impl_notref) _Deref_post1_impl_(__bytecount_x_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_bytecount_x_, (size), _Deref_post1_impl_(__maybenull_impl_notref) _Deref_post1_impl_(__bytecount_x_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_valid_, (), _Deref_post1_impl_(__notnull_impl_notref) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_post_opt_valid_, (), _Deref_post1_impl_(__maybenull_impl_notref) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Deref_ret_z_, (), _Deref_ret1_impl_(__notnull_impl_notref) _Deref_ret1_impl_(__zterm_impl))


text:
_SAL1_1_Source_(_Deref_ret_opt_z_, (), _Deref_ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__zterm_impl))


text:
_SAL1_1_Source_(_Ret_cap_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__cap_impl(size)))


text:
_SAL1_1_Source_(_Ret_opt_cap_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__cap_impl(size)))


text:
_SAL1_1_Source_(_Ret_bytecap_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecap_impl(size)))


text:
_SAL1_1_Source_(_Ret_opt_bytecap_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecap_impl(size)))


text:
_SAL1_1_Source_(_Ret_cap_c_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__cap_c_impl(size)))


text:
_SAL1_1_Source_(_Ret_opt_cap_c_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__cap_c_impl(size)))


text:
_SAL1_1_Source_(_Ret_bytecap_c_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecap_c_impl(size)))


text:
_SAL1_1_Source_(_Ret_opt_bytecap_c_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecap_c_impl(size)))


text:
_SAL1_1_Source_(_Ret_cap_x_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__cap_x_impl(size)))


text:
_SAL1_1_Source_(_Ret_opt_cap_x_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__cap_x_impl(size)))


text:
_SAL1_1_Source_(_Ret_bytecap_x_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecap_x_impl(size)))


text:
_SAL1_1_Source_(_Ret_opt_bytecap_x_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecap_x_impl(size)))


text:
_SAL1_1_Source_(_Ret_z_cap_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret2_impl_(__zterm_impl,__cap_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_opt_z_cap_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret2_impl_(__zterm_impl,__cap_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_z_bytecap_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret2_impl_(__zterm_impl,__bytecap_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_opt_z_bytecap_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret2_impl_(__zterm_impl,__bytecap_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_count_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__count_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_opt_count_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__count_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_bytecount_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecount_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_opt_bytecount_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecount_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_count_c_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__count_c_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_opt_count_c_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__count_c_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_bytecount_c_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecount_c_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_opt_bytecount_c_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecount_c_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_count_x_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__count_x_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_opt_count_x_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__count_x_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_bytecount_x_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret1_impl_(__bytecount_x_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_opt_bytecount_x_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret1_impl_(__bytecount_x_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_z_count_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret2_impl_(__zterm_impl,__count_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_opt_z_count_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret2_impl_(__zterm_impl,__count_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_z_bytecount_, (size), _Ret1_impl_(__notnull_impl_notref) _Ret2_impl_(__zterm_impl,__bytecount_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Ret_opt_z_bytecount_, (size), _Ret1_impl_(__maybenull_impl_notref) _Ret2_impl_(__zterm_impl,__bytecount_impl(size)) _Ret_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_z_, (), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__zterm_impl) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_cap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_impl(size)))


text:
_SAL1_1_Source_(_Pre_opt_cap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_impl(size)))


text:
_SAL1_1_Source_(_Pre_bytecap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_impl(size)))


text:
_SAL1_1_Source_(_Pre_opt_bytecap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_impl(size)))


text:
_SAL1_1_Source_(_Pre_cap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_c_impl(size)))


text:
_SAL1_1_Source_(_Pre_opt_cap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_c_impl(size)))


text:
_SAL1_1_Source_(_Pre_bytecap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_c_impl(size)))


text:
_SAL1_1_Source_(_Pre_opt_bytecap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_c_impl(size)))


text:
_SAL1_1_Source_(_Pre_cap_c_one_, (), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_c_one_notref_impl))


text:
_SAL1_1_Source_(_Pre_opt_cap_c_one_, (), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_c_one_notref_impl))


text:
_SAL1_1_Source_(_Pre_cap_m_, (mult,size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__mult_impl(mult,size)))


text:
_SAL1_1_Source_(_Pre_opt_cap_m_, (mult,size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__mult_impl(mult,size)))


text:
_SAL1_1_Source_(_Pre_cap_for_, (param), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_for_impl(param)))


text:
_SAL1_1_Source_(_Pre_opt_cap_for_, (param), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_for_impl(param)))


text:
_SAL1_1_Source_(_Pre_cap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_x_impl(size)))


text:
_SAL1_1_Source_(_Pre_opt_cap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_x_impl(size)))


text:
_SAL1_1_Source_(_Pre_bytecap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_x_impl(size)))


text:
_SAL1_1_Source_(_Pre_opt_bytecap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_x_impl(size)))


text:
_SAL1_1_Source_(_Pre_ptrdiff_cap_, (ptr), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_x_impl(__ptrdiff(ptr))))


text:
_SAL1_1_Source_(_Pre_opt_ptrdiff_cap_, (ptr), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_x_impl(__ptrdiff(ptr))))


text:
_SAL1_1_Source_(_Pre_z_cap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_z_cap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_z_bytecap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_z_bytecap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_z_cap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_z_cap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_z_bytecap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_z_bytecap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_z_cap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_z_cap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__cap_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_z_bytecap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_z_bytecap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre2_impl_(__zterm_impl,__bytecap_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_valid_cap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_valid_cap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_valid_bytecap_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_valid_bytecap_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_valid_cap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_valid_cap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_valid_bytecap_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_valid_bytecap_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_valid_cap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__cap_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_valid_cap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__cap_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_valid_bytecap_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecap_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_valid_bytecap_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecap_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_count_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__count_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_count_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__count_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_bytecount_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecount_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_bytecount_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecount_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_count_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__count_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_count_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__count_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_bytecount_c_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecount_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_bytecount_c_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecount_c_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_count_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__count_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_count_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__count_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_bytecount_x_, (size), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__bytecount_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_bytecount_x_, (size), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__bytecount_x_impl(size)) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_ptrdiff_count_, (ptr), _Pre1_impl_(__notnull_impl_notref) _Pre1_impl_(__count_x_impl(__ptrdiff(ptr))) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Pre_opt_ptrdiff_count_, (ptr), _Pre1_impl_(__maybenull_impl_notref) _Pre1_impl_(__count_x_impl(__ptrdiff(ptr))) _Pre_valid_impl_)


text:
_SAL1_1_Source_(_Post_bytecount_c_, (size), _Post1_impl_(__bytecount_c_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Post_bytecount_x_, (size), _Post1_impl_(__bytecount_x_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Post_z_count_, (size), _Post2_impl_(__zterm_impl,__count_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Post_z_bytecount_, (size), _Post2_impl_(__zterm_impl,__bytecount_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Post_z_count_c_, (size), _Post2_impl_(__zterm_impl,__count_c_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Post_z_bytecount_c_, (size), _Post2_impl_(__zterm_impl,__bytecount_c_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Post_z_count_x_, (size), _Post2_impl_(__zterm_impl,__count_x_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Post_z_bytecount_x_, (size), _Post2_impl_(__zterm_impl,__bytecount_x_impl(size)) _Post_valid_impl_)


text:
_SAL1_1_Source_(_Prepost_opt_bytecount_c_, (size), _Pre_opt_bytecount_c_(size) _Post_bytecount_c_(size))


text:
_SAL1_1_Source_(_Prepost_opt_bytecount_x_, (size), _Pre_opt_bytecount_x_(size) _Post_bytecount_x_(size))


text:
_SAL1_1_Source_(_Deref_prepost_opt_cap_, (size), _Deref_pre_opt_cap_(size) _Deref_post_opt_cap_(size))


text:
_SAL1_1_Source_(_Deref_prepost_bytecap_, (size), _Deref_pre_bytecap_(size) _Deref_post_bytecap_(size))


text:
_SAL1_1_Source_(_Deref_prepost_opt_bytecap_, (size), _Deref_pre_opt_bytecap_(size) _Deref_post_opt_bytecap_(size))


text:
_SAL1_1_Source_(_Deref_prepost_opt_cap_x_, (size), _Deref_pre_opt_cap_x_(size) _Deref_post_opt_cap_x_(size))


text:
_SAL1_1_Source_(_Deref_prepost_bytecap_x_, (size), _Deref_pre_bytecap_x_(size) _Deref_post_bytecap_x_(size))


text:
_SAL1_1_Source_(_Deref_prepost_opt_bytecap_x_, (size), _Deref_pre_opt_bytecap_x_(size) _Deref_post_opt_bytecap_x_(size))


text:
_SAL1_1_Source_(_Deref_prepost_opt_z_cap_, (size), _Deref_pre_opt_z_cap_(size) _Deref_post_opt_z_cap_(size))


text:
_SAL1_1_Source_(_Deref_prepost_z_bytecap_, (size), _Deref_pre_z_bytecap_(size) _Deref_post_z_bytecap_(size))


text:
_SAL1_1_Source_(_Deref_prepost_opt_z_bytecap_, (size), _Deref_pre_opt_z_bytecap_(size) _Deref_post_opt_z_bytecap_(size))


text:
_SAL1_1_Source_(_Deref_prepost_valid_cap_, (size), _Deref_pre_valid_cap_(size) _Deref_post_valid_cap_(size))


text:
_SAL1_1_Source_(_Deref_prepost_opt_valid_cap_, (size), _Deref_pre_opt_valid_cap_(size) _Deref_post_opt_valid_cap_(size))


text:
_SAL1_1_Source_(_Deref_prepost_valid_bytecap_, (size), _Deref_pre_valid_bytecap_(size) _Deref_post_valid_bytecap_(size))


text:
_SAL1_1_Source_(_Deref_prepost_opt_valid_bytecap_, (size), _Deref_pre_opt_valid_bytecap_(size) _Deref_post_opt_valid_bytecap_(size))


text:
_SAL1_1_Source_(_Deref_prepost_valid_cap_x_, (size), _Deref_pre_valid_cap_x_(size) _Deref_post_valid_cap_x_(size))


text:
_SAL1_1_Source_(_Deref_prepost_opt_valid_cap_x_, (size), _Deref_pre_opt_valid_cap_x_(size) _Deref_post_opt_valid_cap_x_(size))


text:
_SAL1_1_Source_(_Deref_prepost_valid_bytecap_x_, (size), _Deref_pre_valid_bytecap_x_(size) _Deref_post_valid_bytecap_x_(size))


text:
_SAL1_1_Source_(_Deref_prepost_opt_valid_bytecap_x_, (size), _Deref_pre_opt_valid_bytecap_x_(size) _Deref_post_opt_valid_bytecap_x_(size))


text:
_SAL1_1_Source_(_Deref_prepost_opt_count_, (size), _Deref_pre_opt_count_(size) _Deref_post_opt_count_(size))


text:
_SAL1_1_Source_(_Deref_prepost_bytecount_, (size), _Deref_pre_bytecount_(size) _Deref_post_bytecount_(size))


text:
_SAL1_1_Source_(_Deref_prepost_opt_bytecount_, (size), _Deref_pre_opt_bytecount_(size) _Deref_post_opt_bytecount_(size))


text:
_SAL1_1_Source_(_Deref_prepost_count_x_, (size), _Deref_pre_count_x_(size) _Deref_post_count_x_(size))


text:
_SAL1_1_Source_(_Deref_prepost_opt_count_x_, (size), _Deref_pre_opt_count_x_(size) _Deref_post_opt_count_x_(size))


text:
_SAL1_1_Source_(_Deref_prepost_bytecount_x_, (size), _Deref_pre_bytecount_x_(size) _Deref_post_bytecount_x_(size))


text:
_SAL1_1_Source_(_Deref_prepost_opt_bytecount_x_, (size), _Deref_pre_opt_bytecount_x_(size) _Deref_post_opt_bytecount_x_(size))


text:
_Group_(_SA_annotes1(SAL_nullTerminated, __yes) _SA_annotes1(SAL_readableTo,inexpressibleCount("NullNull terminated string")))


text:
_SAL1_Source_(__out_z_opt, (), __post __valid __refparam __post __nullterminated __pre_except_maybenull)


text:
_SAL1_Source_(__out_ecount_z, (size), __ecount(size) __post __valid __refparam __post __nullterminated)


text:
_SAL1_Source_(__out_bcount_z, (size), __bcount(size) __post __valid __refparam __post __nullterminated)


text:
_SAL1_Source_(__out_ecount_part_z, (size,length), __out_ecount_part(size,length) __post __nullterminated)


text:
_SAL1_Source_(__out_bcount_part_z, (size,length), __out_bcount_part(size,length) __post __nullterminated)


text:
_SAL1_Source_(__inout_bcount_z, (size), __inout_bcount(size) __pre __nullterminated __post __nullterminated)


text:
_SAL1_Source_(__out_ecount_part_opt, (size,length), __out_ecount_part(size,length) __pre_except_maybenull)


text:
_SAL1_Source_(__out_bcount_part_opt, (size,length), __out_bcount_part(size,length) __pre_except_maybenull)


text:
_SAL1_Source_(__out_ecount_part_z_opt, (size,length), __out_ecount_part_opt(size,length) __post __nullterminated)


text:
_SAL1_Source_(__out_bcount_part_z_opt, (size,length), __out_bcount_part_opt(size,length) __post __nullterminated)


text:
_SAL1_Source_(__inout_ecount_part_opt, (size,length), __inout_ecount_part(size,length) __pre_except_maybenull)


text:
_SAL1_Source_(__inout_bcount_part_opt, (size,length), __inout_bcount_part(size,length) __pre_except_maybenull)


text:
_SAL1_Source_(__inout_ecount_z_opt, (size), __inout_ecount_opt(size) __pre __nullterminated __post __nullterminated)


text:
_SAL1_Source_(__deref_ecount, (size), _Notref_ __ecount(1) __post _Notref_ __elem_readableTo(1) __post _Notref_ __deref _Notref_ __notnull __post __deref __elem_writableTo(size))


text:
_SAL1_Source_(__deref_bcount, (size), _Notref_ __ecount(1) __post _Notref_ __elem_readableTo(1) __post _Notref_ __deref _Notref_ __notnull __post __deref __byte_writableTo(size))


text:
_SAL1_Source_(__deref_out_ecount_z, (size), __deref_out_ecount(size) __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_out_bcount_z, (size), __deref_out_bcount(size) __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_inout, (), _Notref_ __notnull _Notref_ __elem_readableTo(1) __pre __deref __valid __post _Notref_ __deref __valid __refparam)


text:
_SAL1_Source_(__deref_inout_z, (), __deref_inout __pre __deref __nullterminated __post _Notref_ __deref __nullterminated)


text:
_SAL1_Source_(__deref_inout_ecount, (size), __deref_inout __pre __deref __elem_writableTo(size) __post _Notref_ __deref __elem_writableTo(size))


text:
_SAL1_Source_(__deref_inout_bcount, (size), __deref_inout __pre __deref __byte_writableTo(size) __post _Notref_ __deref __byte_writableTo(size))


text:
_SAL1_Source_(__deref_inout_ecount_part, (size,length), __deref_inout_ecount(size) __pre __deref __elem_readableTo(length) __post __deref __elem_readableTo(length))


text:
_SAL1_Source_(__deref_inout_bcount_part, (size,length), __deref_inout_bcount(size) __pre __deref __byte_readableTo(length) __post __deref __byte_readableTo(length))


text:
_SAL1_Source_(__deref_inout_ecount_z, (size), __deref_inout_ecount(size) __pre __deref __nullterminated __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_inout_bcount_z, (size), __deref_inout_bcount(size) __pre __deref __nullterminated __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_out_ecount_opt, (size), __deref_out_ecount(size) __post_deref_except_maybenull)


text:
_SAL1_Source_(__deref_out_bcount_opt, (size), __deref_out_bcount(size) __post_deref_except_maybenull)


text:
_SAL1_Source_(__deref_out_ecount_part_opt, (size,length), __deref_out_ecount_part(size,length) __post_deref_except_maybenull)


text:
_SAL1_Source_(__deref_out_bcount_part_opt, (size,length), __deref_out_bcount_part(size,length) __post_deref_except_maybenull)


text:
_SAL1_Source_(__deref_out_ecount_full_opt, (size), __deref_out_ecount_full(size) __post_deref_except_maybenull)


text:
_SAL1_Source_(__deref_out_bcount_full_opt, (size), __deref_out_bcount_full(size) __post_deref_except_maybenull)


text:
_SAL1_Source_(__deref_out_ecount_z_opt, (size), __deref_out_ecount_opt(size) __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_out_bcount_z_opt, (size), __deref_out_bcount_opt(size) __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_inout_opt, (), __deref_inout __pre_deref_except_maybenull __post_deref_except_maybenull)


text:
_SAL1_Source_(__deref_inout_ecount_opt, (size), __deref_inout_ecount(size) __pre_deref_except_maybenull __post_deref_except_maybenull)


text:
_SAL1_Source_(__deref_inout_bcount_opt, (size), __deref_inout_bcount(size) __pre_deref_except_maybenull __post_deref_except_maybenull)


text:
_SAL1_Source_(__deref_inout_ecount_part_opt, (size,length), __deref_inout_ecount_part(size,length) __pre_deref_except_maybenull __post_deref_except_maybenull)


text:
_SAL1_Source_(__deref_inout_bcount_part_opt, (size,length), __deref_inout_bcount_part(size,length) __pre_deref_except_maybenull __post_deref_except_maybenull)


text:
_SAL1_Source_(__deref_inout_ecount_full_opt, (size), __deref_inout_ecount_full(size) __pre_deref_except_maybenull __post_deref_except_maybenull)


text:
_SAL1_Source_(__deref_inout_bcount_full_opt, (size), __deref_inout_bcount_full(size) __pre_deref_except_maybenull __post_deref_except_maybenull)


text:
_SAL1_Source_(__deref_inout_z_opt, (), __deref_inout_opt __pre __deref __nullterminated __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_inout_ecount_z_opt, (size), __deref_inout_ecount_opt(size) __pre __deref __nullterminated __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_inout_bcount_z_opt, (size), __deref_inout_bcount_opt(size) __pre __deref __nullterminated __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_opt_out_ecount_part, (size,length), __deref_out_ecount_part(size,length) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_out_bcount_part, (size,length), __deref_out_bcount_part(size,length) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_out_ecount_full, (size), __deref_out_ecount_full(size) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_out_bcount_full, (size), __deref_out_bcount_full(size) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_inout_ecount_part, (size,length), __deref_inout_ecount_part(size,length) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_inout_bcount_part, (size,length), __deref_inout_bcount_part(size,length) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_inout_ecount_full, (size), __deref_inout_ecount_full(size) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_inout_bcount_full, (size), __deref_inout_bcount_full(size) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_inout_z, (), __deref_opt_inout __pre __deref __nullterminated __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_opt_inout_ecount_z, (size), __deref_opt_inout_ecount(size) __pre __deref __nullterminated __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_opt_inout_bcount_z, (size), __deref_opt_inout_bcount(size) __pre __deref __nullterminated __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_opt_out_ecount_opt, (size), __deref_out_ecount_opt(size) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_out_bcount_opt, (size), __deref_out_bcount_opt(size) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_out_ecount_part_opt, (size,length), __deref_out_ecount_part_opt(size,length) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_out_bcount_part_opt, (size,length), __deref_out_bcount_part_opt(size,length) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_out_ecount_full_opt, (size), __deref_out_ecount_full_opt(size) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_out_bcount_full_opt, (size), __deref_out_bcount_full_opt(size) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_out_z_opt, (), __post __deref __valid __refparam __pre_except_maybenull __pre_deref_except_maybenull __post_deref_except_maybenull __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_opt_out_ecount_z_opt, (size), __deref_opt_out_ecount_opt(size) __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_opt_out_bcount_z_opt, (size), __deref_opt_out_bcount_opt(size) __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_opt_inout_ecount_opt, (size), __deref_inout_ecount_opt(size) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_inout_bcount_opt, (size), __deref_inout_bcount_opt(size) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_inout_ecount_part_opt, (size,length), __deref_inout_ecount_part_opt(size,length) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_inout_bcount_part_opt, (size,length), __deref_inout_bcount_part_opt(size,length) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_inout_ecount_full_opt, (size), __deref_inout_ecount_full_opt(size) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_inout_bcount_full_opt, (size), __deref_inout_bcount_full_opt(size) __pre_except_maybenull)


text:
_SAL1_Source_(__deref_opt_inout_z_opt, (), __deref_opt_inout_opt __pre __deref __nullterminated __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_opt_inout_ecount_z_opt, (size), __deref_opt_inout_ecount_opt(size) __pre __deref __nullterminated __post __deref __nullterminated)


text:
_SAL1_Source_(__deref_opt_inout_bcount_z_opt, (size), __deref_opt_inout_bcount_opt(size) __pre __deref __nullterminated __post __deref __nullterminated)


text:
__pragma(warning(disable: 28110 28111 28161 28162)) typedef _Analysis_mode_impl_(mode) int __GENSYM(__prefast_analysis_mode_flag);


text:
do { __m256 _a = (a); _mm_storeu_ps((loaddr), _mm256_castps256_ps128(_a)); _mm_storeu_ps((hiaddr), _mm256_extractf128_ps(_a, 0x1)); } while (0)


text:
do { __m256d _a = (a); _mm_storeu_pd((loaddr), _mm256_castpd256_pd128(_a)); _mm_storeu_pd((hiaddr), _mm256_extractf128_pd(_a, 0x1)); } while (0)


text:
do { __m256i _a = (a); _mm_storeu_si128((loaddr), _mm256_castsi256_si128(_a)); _mm_storeu_si128((hiaddr), _mm256_extractf128_si256(_a, 0x1)); } while (0)


text:
(_ARMINTR_ASSERT(_ARMINTR_IN_RANGE((val), (low), (high)), name " is out of range '" #low " - " #high "'"))


text:
(_ARMINTR_ASSERT(((type) == _ARM_LSL) || ((type) == _ARM_ASR), "shift type must be _ARM_LSL or _ARM_ASR"), _ARMINTR_ASSERT(((type) != _ARM_LSL) || _ARMINTR_IN_RANGE((amt), 0, 31), "shift is out of range '0 - 31'"), _ARMINTR_ASSERT(((type) != _ARM_ASR) || _ARMINTR_IN_RANGE((amt), 1, 31), "shift is out of range '1 - 31'"))


text:
(_ARMINTR_ASSERT(((type) == _ARM_LSL) || ((type) == _ARM_ASR), "shift type must be _ARM_LSL or _ARM_ASR"), _ARMINTR_ASSERT(((type) != _ARM_LSL) || _ARMINTR_IN_RANGE((amt), 0, 31), "shift is out of range '0 - 31'"), _ARMINTR_ASSERT(((type) != _ARM_ASR) || _ARMINTR_IN_RANGE((amt), 1, 32), "shift is out of range '1 - 32'"))


text:
(_ARMINTR_ASSERT_ROT(_Rotation), __arm_gen_s_Rd_RnRm(_ARMINTR_SXTAB | _ARMINTR_ENCODE_XTROT(_Rotation), (_Rn), (_Rm)))


text:
(_ARMINTR_ASSERT_ROT(_Rotation), __arm_gen_s_Rd_RnRm(_ARMINTR_SXTAB16 | _ARMINTR_ENCODE_XTROT(_Rotation), (_Rn), (_Rm)))


text:
(_ARMINTR_ASSERT_ROT(_Rotation), __arm_gen_s_Rd_RnRm(_ARMINTR_SXTAH | _ARMINTR_ENCODE_XTROT(_Rotation), (_Rn), (_Rm)))


text:
(_ARMINTR_ASSERT_ROT(_Rotation), __arm_gen_u_Rd_RnRm(_ARMINTR_UXTAB | _ARMINTR_ENCODE_XTROT(_Rotation), (_Rn), (_Rm)))


text:
(_ARMINTR_ASSERT_ROT(_Rotation), __arm_gen_u_Rd_RnRm(_ARMINTR_UXTAB16 | _ARMINTR_ENCODE_XTROT(_Rotation), (_Rn), (_Rm)))


text:
(_ARMINTR_ASSERT_ROT(_Rotation), __arm_gen_u_Rd_RnRm(_ARMINTR_UXTAH | _ARMINTR_ENCODE_XTROT(_Rotation), (_Rn), (_Rm)))


text:
(_ARMINTR_ASSERT_ROT(_Rotation), __arm_gen_s_Rd_Rm(_ARMINTR_SXTB | _ARMINTR_ENCODE_XTROT(_Rotation), (_Rn)))


text:
(_ARMINTR_ASSERT_ROT(_Rotation), __arm_gen_s_Rd_Rm(_ARMINTR_SXTB16 | _ARMINTR_ENCODE_XTROT(_Rotation), (_Rn)))


text:
(_ARMINTR_ASSERT_ROT(_Rotation), __arm_gen_s_Rd_Rm(_ARMINTR_SXTH | _ARMINTR_ENCODE_XTROT(_Rotation), (_Rn)))


text:
(_ARMINTR_ASSERT_ROT(_Rotation), __arm_gen_u_Rd_Rm(_ARMINTR_UXTB | _ARMINTR_ENCODE_XTROT(_Rotation), (_Rn)))


text:
(_ARMINTR_ASSERT_ROT(_Rotation), __arm_gen_u_Rd_Rm(_ARMINTR_UXTB16 | _ARMINTR_ENCODE_XTROT(_Rotation), (_Rn)))


text:
(_ARMINTR_ASSERT_ROT(_Rotation), __arm_gen_u_Rd_Rm(_ARMINTR_UXTBH | _ARMINTR_ENCODE_XTROT(_Rotation), (_Rn)))


text:
(_ARMINTR_ASSERT_RANGE((_Lsl_imm), 0, 31, "logical left shift"), __arm_gen_s_Rd_RnRm(_ARMINTR_PKHBT | _ARMINTR_ENCODE_PKHSHIFT(_Lsl_imm), (_Rn), (_Rm)))


text:
(_ARMINTR_ASSERT_RANGE((_Asr_imm), 1, 32, "arithmetic right shift"), __arm_gen_s_Rd_RnRm(_ARMINTR_PKHTB | _ARMINTR_ENCODE_PKHSHIFT(_Asr_imm), (_Rn), (_Rm)))


text:
(_ARMINTR_ASSERT_SAT_BIT((_Sat_imm), 1, 32), _ARMINTR_ASSERT_SAT_SHIFT((_Shift_type), (_Shift_imm)), _ARMINTR_S_DMx(_ARMINTR_SSAT | _ARMINTR_ENCODE_IMM5_16((_Sat_imm) - 1) | _ARMINTR_ENCODE_SAT_SH((_Shift_type), (_Shift_imm)), (_Rn)))


text:
(_ARMINTR_ASSERT_SAT_BIT((_Sat_imm), 0, 31), _ARMINTR_ASSERT_SAT_SHIFT((_Shift_type), (_Shift_imm)), _ARMINTR_S_DMx(_ARMINTR_USAT | _ARMINTR_ENCODE_IMM5_16(_Sat_imm) | _ARMINTR_ENCODE_SAT_SH((_Shift_type), (_Shift_imm)), (_Rn)))


text:
(_ARMINTR_ASSERT_SAT_BIT((_Sat_imm), 1, 16), _ARMINTR_S_DMx(_ARMINTR_SSAT16 | _ARMINTR_ENCODE_IMM4_16((_Sat_imm) - 1), (_Rn)))


text:
(_ARMINTR_ASSERT_SAT_BIT((_Sat_imm), 0, 15), _ARMINTR_S_DMx(_ARMINTR_USAT16 | _ARMINTR_ENCODE_IMM4_16(_Sat_imm), (_Rn)))


text:
(__arm_gen_u_Rdn_RdnRmRs(_ARMINTR_UMAAL, ((unsigned __int64)(_RdHi) << 32) | (_RdLo), (_Rn), (_Rm)))


text:
(_ARMINTR_ASSERT_RANGE((_Lsb), 0, 31, "least significant bit"), _ARMINTR_ASSERT_RANGE((_Width), 1, 32-(_Lsb), "width"), __arm_gen_u_Rd_Rd(_ARMINTR_BFC | _ARMINTR_ENCODE_IMM5_7(_Lsb) | _ARMINTR_ENCODE_IMM5_16((_Lsb) + (_Width) - 1), (_Rd)))


text:
(_ARMINTR_ASSERT_RANGE((_Lsb), 0, 31, "least significant bit"), _ARMINTR_ASSERT_RANGE((_Width), 1, 32-(_Lsb), "width"), _ARMINTR_U_DDMx(_ARMINTR_BFI | _ARMINTR_ENCODE_IMM5_7(_Lsb) | _ARMINTR_ENCODE_IMM5_16((_Lsb) + (_Width) - 1), (_Rd), (_Rn)))


text:
(_ARMINTR_ASSERT_RANGE((_Lsb), 0, 31, "least significant bit"), _ARMINTR_ASSERT_RANGE((_Width), 1, 32-(_Lsb), "width"), _ARMINTR_S_DMx(_ARMINTR_SBFX | _ARMINTR_ENCODE_IMM5_7(_Lsb) | _ARMINTR_ENCODE_IMM5_16((_Width) - 1), (_Rn)))


text:
(_ARMINTR_ASSERT_RANGE((_Lsb), 0, 31, "least significant bit"), _ARMINTR_ASSERT_RANGE((_Width), 1, 32-(_Lsb), "width"), _ARMINTR_U_DMx(_ARMINTR_UBFX | _ARMINTR_ENCODE_IMM5_7(_Lsb) | _ARMINTR_ENCODE_IMM5_16((_Width) - 1), (_Rn)))


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) <= 8, "invalid shift amount"), ((shift_amount) == 8) ? __internal_vshll_n_t2_s8((Dm)) : __internal_vshll_n_t1_s8((Dm), (shift_amount)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) <= 16, "invalid shift amount"), ((shift_amount) == 16) ? __internal_vshll_n_t2_s16((Dm)) : __internal_vshll_n_t1_s16((Dm), (shift_amount)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) <= 32, "invalid shift amount"), ((shift_amount) == 32) ? __internal_vshll_n_t2_s32((Dm)) : __internal_vshll_n_t1_s32((Dm), (shift_amount)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) <= 8, "invalid shift amount"), ((shift_amount) == 8) ? __internal_vshll_n_t2_u8((Dm)) : __internal_vshll_n_t1_u8((Dm), (shift_amount)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) <= 16, "invalid shift amount"), ((shift_amount) == 16) ? __internal_vshll_n_t2_u16((Dm)) : __internal_vshll_n_t1_u16((Dm), (shift_amount)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) <= 32, "invalid shift amount"), ((shift_amount) == 32) ? __internal_vshll_n_t2_u32((Dm)) : __internal_vshll_n_t1_u32((Dm), (shift_amount)) )


text:
( __static_assert((fbits) >= 1 && (fbits) <= 32, "invalid fbits value"), __neon_DdDm( 0xf2800e10 | _NENC_21_16(64 - (fbits)), (Dm)) )


text:
( __static_assert((fbits) >= 1 && (fbits) <= 32, "invalid fbits value"), __neon_DdDm( 0xf3800e10 | _NENC_21_16(64 - (fbits)), (Dm)) )


text:
( __static_assert((fbits) >= 1 && (fbits) <= 32, "invalid fbits value"), __neon_DdDm( 0xf2800f10 | _NENC_21_16(64 - (fbits)), (Dm)) )


text:
( __static_assert((fbits) >= 1 && (fbits) <= 32, "invalid fbits value"), __neon_DdDm( 0xf3800f10 | _NENC_21_16(64 - (fbits)), (Dm)) )


text:
( __static_assert((fbits) >= 1 && (fbits) <= 32, "invalid fbits value"), __neon_QdQm( 0xf2800e50 | _NENC_21_16(64 - (fbits)), (Qm)) )


text:
( __static_assert((fbits) >= 1 && (fbits) <= 32, "invalid fbits value"), __neon_QdQm( 0xf3800e50 | _NENC_21_16(64 - (fbits)), (Qm)) )


text:
( __static_assert((fbits) >= 1 && (fbits) <= 32, "invalid fbits value"), __neon_QdQm( 0xf2800f50 | _NENC_21_16(64 - (fbits)), (Qm)) )


text:
( __static_assert((fbits) >= 1 && (fbits) <= 32, "invalid fbits value"), __neon_QdQm( 0xf3800f50 | _NENC_21_16(64 - (fbits)), (Qm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDm( 0xf3b40c00 | _NENC_19(lane), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDm( 0xf3b20c00 | _NENC_19_18(lane), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_DdDm( 0xf3b10c00 | _NENC_19_17(lane), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDm( 0xf3b40c40 | _NENC_19(lane), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDm( 0xf3b20c40 | _NENC_19_18(lane), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_QdDm( 0xf3b10c40 | _NENC_19_17(lane), (Dm)) )


text:
( __static_assert((pos) >= 0 && (pos) < 2, "invalid position value"), __neon_DdDnDm( 0xf2b00000 | _NENC_11_8((pos) * 4), (Dn), (Dm)) )


text:
( __static_assert((pos) >= 0 && (pos) < 4, "invalid position value"), __neon_DdDnDm( 0xf2b00000 | _NENC_11_8((pos) * 2), (Dn), (Dm)) )


text:
( __static_assert((pos) >= 0 && (pos) < 8, "invalid position value"), __neon_DdDnDm( 0xf2b00000 | _NENC_11_8(pos), (Dn), (Dm)) )


text:
( __static_assert((pos) >= 0 && (pos) < 1, "invalid position value"), __neon_DdDnDm( 0xf2b00000 | _NENC_11_8((pos) * 8), (Dn), (Dm)) )


text:
( __static_assert((pos) >= 0 && (pos) < 4, "invalid position value"), __neon_QdQnQm( 0xf2b00040 | _NENC_11_8((pos) * 4), (Qn), (Qm)) )


text:
( __static_assert((pos) >= 0 && (pos) < 8, "invalid position value"), __neon_QdQnQm( 0xf2b00040 | _NENC_11_8((pos) * 2), (Qn), (Qm)) )


text:
( __static_assert((pos) >= 0 && (pos) < 16, "invalid position value"), __neon_QdQnQm( 0xf2b00040 | _NENC_11_8(pos), (Qn), (Qm)) )


text:
( __static_assert((pos) >= 0 && (pos) < 2, "invalid position value"), __neon_QdQnQm( 0xf2b00040 | _NENC_11_8((pos) * 8), (Qn), (Qm)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420078f | _NENC_5_4(_NEON_ALIGN64(align)), __float32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420074f | _NENC_5_4(_NEON_ALIGN64(align)), __poly16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420070f | _NENC_5_4(_NEON_ALIGN64(align)), __poly8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420074f | _NENC_5_4(_NEON_ALIGN64(align)), __int16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420078f | _NENC_5_4(_NEON_ALIGN64(align)), __int32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf42007cf | _NENC_5_4(_NEON_ALIGN64(align)), __int64ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420070f | _NENC_5_4(_NEON_ALIGN64(align)), __int8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420074f | _NENC_5_4(_NEON_ALIGN64(align)), __uint16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420078f | _NENC_5_4(_NEON_ALIGN64(align)), __uint32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf42007cf | _NENC_5_4(_NEON_ALIGN64(align)), __uint64ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_D1Adr( 0xf420070f | _NENC_5_4(_NEON_ALIGN64(align)), __uint8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a8f | _NENC_5_4(_NEON_ALIGN64_128(align)), __float32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a4f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a0f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a4f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a8f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __int64ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a0f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a4f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a8f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint64ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4200a0f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_D1Adr( 0xf4a00c8f | _NENC_4(_NEON_ALIGN32(align)), __float32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_D1Adr( 0xf4a00c4f | _NENC_4(_NEON_ALIGN16(align)), __poly16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_D1Adr( 0xf4a00c4f | _NENC_4(_NEON_ALIGN16(align)), __int16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_D1Adr( 0xf4a00c8f | _NENC_4(_NEON_ALIGN32(align)), __int32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_D1Adr( 0xf4a00c4f | _NENC_4(_NEON_ALIGN16(align)), __uint16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_D1Adr( 0xf4a00c8f | _NENC_4(_NEON_ALIGN32(align)), __uint32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4a00caf | _NENC_4(_NEON_ALIGN32(align)), __float32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4a00c6f | _NENC_4(_NEON_ALIGN16(align)), __poly16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4a00c6f | _NENC_4(_NEON_ALIGN16(align)), __int16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4a00caf | _NENC_4(_NEON_ALIGN32(align)), __int32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4a00c6f | _NENC_4(_NEON_ALIGN16(align)), __uint16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Q1Adr( 0xf4a00caf | _NENC_4(_NEON_ALIGN32(align)), __uint32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0080f | _NENC_7(lane), (Dd), __float32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0040f | _NENC_7_6(lane), (Dd), __poly16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0000f | _NENC_7_5(lane), (Dd), __poly8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0040f | _NENC_7_6(lane), (Dd), __int16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0080f | _NENC_7(lane), (Dd), __int32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0000f | _NENC_7_5(lane), (Dd), __int8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0040f | _NENC_7_6(lane), (Dd), __uint16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0080f | _NENC_7(lane), (Dd), __uint32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_D1Adr_acc( 0xf4a0000f | _NENC_7_5(lane), (Dd), __uint8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Qd), __float32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Qd), __poly16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0000f | _NENC_7_5((lane) % 8) | _NENC_12((lane) >= 8 ? 1 : 0), (Qd), __poly8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Qd), __int16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Qd), __int32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0000f | _NENC_7_5((lane) % 8) | _NENC_12((lane) >= 8 ? 1 : 0), (Qd), __int8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Qd), __uint16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Qd), __uint32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_Q1Adr_acc( 0xf4a0000f | _NENC_7_5((lane) % 8) | _NENC_12((lane) >= 8 ? 1 : 0), (Qd), __uint8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_D1Adr_acc( 0xf4a0080f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), (Dd), __float32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_D1Adr_acc( 0xf4a0040f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN16(align)), (Dd), __poly16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_D1Adr_acc( 0xf4a0040f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN16(align)), (Dd), __int16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_D1Adr_acc( 0xf4a0080f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), (Dd), __int32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_D1Adr_acc( 0xf4a0040f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN16(align)), (Dd), __uint16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_D1Adr_acc( 0xf4a0080f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), (Dd), __uint32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Q1Adr_acc( 0xf4a0080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), (Qd), __float32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Q1Adr_acc( 0xf4a0040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN16(align)), (Qd), __poly16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Q1Adr_acc( 0xf4a0040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN16(align)), (Qd), __int16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Q1Adr_acc( 0xf4a0080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), (Qd), __int32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Q1Adr_acc( 0xf4a0040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN16(align)), (Qd), __uint16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Q1Adr_acc( 0xf4a0080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), (Qd), __uint32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4200acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __int64ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4200acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint64ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420088f | _NENC_5_4(_NEON_ALIGN64_128(align)), __float32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420084f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420080f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420084f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420088f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420080f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420084f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420088f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf420080f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420098f | _NENC_5_4(_NEON_ALIGN64_128(align)), __float32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420094f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420090f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420094f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420098f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420090f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420094f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420098f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx2Adr( 0xf420090f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d8f | _NENC_4(_NEON_ALIGN64(align)), __float32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d4f | _NENC_4(_NEON_ALIGN32(align)), __poly16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d0f | _NENC_4(_NEON_ALIGN16(align)), __poly8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d4f | _NENC_4(_NEON_ALIGN32(align)), __int16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d8f | _NENC_4(_NEON_ALIGN64(align)), __int32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d0f | _NENC_4(_NEON_ALIGN16(align)), __int8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d4f | _NENC_4(_NEON_ALIGN32(align)), __uint16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d8f | _NENC_4(_NEON_ALIGN64(align)), __uint32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Dx2Adr( 0xf4a00d0f | _NENC_4(_NEON_ALIGN16(align)), __uint8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0090f | _NENC_7(lane), (D2), __float32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0050f | _NENC_7_6(lane), (D2), __poly16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0010f | _NENC_7_5(lane), (D2), __poly8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0050f | _NENC_7_6(lane), (D2), __int16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0090f | _NENC_7(lane), (D2), __int32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0010f | _NENC_7_5(lane), (D2), __int8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0050f | _NENC_7_6(lane), (D2), __uint16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0090f | _NENC_7(lane), (D2), __uint32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx2Adr_acc( 0xf4a0010f | _NENC_7_5(lane), (D2), __uint8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx2Adr_acc( 0xf4a0094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q2), __float32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx2Adr_acc( 0xf4a0052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q2), __poly16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx2Adr_acc( 0xf4a0052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q2), __int16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx2Adr_acc( 0xf4a0094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q2), __int32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx2Adr_acc( 0xf4a0052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q2), __uint16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx2Adr_acc( 0xf4a0094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q2), __uint32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0090f | _NENC_7(lane) | _NENC_4(_NEON_ALIGN64(align)), (D2), __float32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0050f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN32(align)), (D2), __poly16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0010f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN16(align)), (D2), __poly8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0050f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN32(align)), (D2), __int16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0090f | _NENC_7(lane) | _NENC_4(_NEON_ALIGN64(align)), (D2), __int32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0010f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN16(align)), (D2), __int8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0050f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN32(align)), (D2), __uint16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0090f | _NENC_7(lane) | _NENC_4(_NEON_ALIGN64(align)), (D2), __uint32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_Dx2Adr_acc( 0xf4a0010f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN16(align)), (D2), __uint8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx2Adr_acc( 0xf4a0094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), (Q2), __float32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Qx2Adr_acc( 0xf4a0052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN32(align)), (Q2), __poly16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Qx2Adr_acc( 0xf4a0052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN32(align)), (Q2), __int16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx2Adr_acc( 0xf4a0094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), (Q2), __int32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Qx2Adr_acc( 0xf4a0052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN32(align)), (Q2), __uint16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx2Adr_acc( 0xf4a0094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), (Q2), __uint32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf42006cf | _NENC_5_4(_NEON_ALIGN64(align)), __int64ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf42006cf | _NENC_5_4(_NEON_ALIGN64(align)), __uint64ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420048f | _NENC_5_4(_NEON_ALIGN64(align)), __float32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420044f | _NENC_5_4(_NEON_ALIGN64(align)), __poly16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420040f | _NENC_5_4(_NEON_ALIGN64(align)), __poly8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420044f | _NENC_5_4(_NEON_ALIGN64(align)), __int16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420048f | _NENC_5_4(_NEON_ALIGN64(align)), __int32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420040f | _NENC_5_4(_NEON_ALIGN64(align)), __int8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420044f | _NENC_5_4(_NEON_ALIGN64(align)), __uint16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420048f | _NENC_5_4(_NEON_ALIGN64(align)), __uint32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx3Adr( 0xf420040f | _NENC_5_4(_NEON_ALIGN64(align)), __uint8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420058f | _NENC_5_4(_NEON_ALIGN64(align)), __float32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420054f | _NENC_5_4(_NEON_ALIGN64(align)), __poly16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420050f | _NENC_5_4(_NEON_ALIGN64(align)), __poly8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420054f | _NENC_5_4(_NEON_ALIGN64(align)), __int16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420058f | _NENC_5_4(_NEON_ALIGN64(align)), __int32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420050f | _NENC_5_4(_NEON_ALIGN64(align)), __int8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420054f | _NENC_5_4(_NEON_ALIGN64(align)), __uint16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420058f | _NENC_5_4(_NEON_ALIGN64(align)), __uint32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx3Adr( 0xf420050f | _NENC_5_4(_NEON_ALIGN64(align)), __uint8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a00a0f | _NENC_7(lane), (D3), __float32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a0060f | _NENC_7_6(lane), (D3), __poly16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a0020f | _NENC_7_5(lane), (D3), __poly8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a0060f | _NENC_7_6(lane), (D3), __int16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a00a0f | _NENC_7(lane), (D3), __int32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a0020f | _NENC_7_5(lane), (D3), __int8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a0060f | _NENC_7_6(lane), (D3), __uint16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a00a0f | _NENC_7(lane), (D3), __uint32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx3Adr_acc( 0xf4a0020f | _NENC_7_5(lane), (D3), __uint8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx3Adr_acc( 0xf4a00a4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q3), __float32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx3Adr_acc( 0xf4a0062f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q3), __poly16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx3Adr_acc( 0xf4a0062f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q3), __int16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx3Adr_acc( 0xf4a00a4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q3), __int32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx3Adr_acc( 0xf4a0062f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q3), __uint16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx3Adr_acc( 0xf4a00a4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q3), __uint32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf42002cf | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int64ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf42002cf | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint64ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420008f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __float32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420004f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __poly16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420000f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __poly8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420004f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420008f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420000f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420004f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420008f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf420000f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420018f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __float32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420014f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __poly16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420010f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __poly8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420014f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420018f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420010f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420014f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420018f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_Qx4Adr( 0xf420010f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f0f | _NENC_7_6(_NEON_ALIGN64_128(align) > 1 ? 3 : 2) | _NENC_4(_NEON_ALIGN64_128(align) > 0 ? 1 : 0), __float32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f4f | _NENC_4(_NEON_ALIGN64(align)), __poly16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f0f | _NENC_4(_NEON_ALIGN32(align)), __poly8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f4f | _NENC_4(_NEON_ALIGN64(align)), __int16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f0f | _NENC_7_6(_NEON_ALIGN64_128(align) > 1 ? 3 : 2) | _NENC_4(_NEON_ALIGN64_128(align) > 0 ? 1 : 0), __int32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f0f | _NENC_4(_NEON_ALIGN32(align)), __int8ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f4f | _NENC_4(_NEON_ALIGN64(align)), __uint16ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f0f | _NENC_7_6(_NEON_ALIGN64_128(align) > 1 ? 3 : 2) | _NENC_4(_NEON_ALIGN64_128(align) > 0 ? 1 : 0), __uint32ToN64_c(pcD)) )


text:
( __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx4Adr( 0xf4a00f0f | _NENC_4(_NEON_ALIGN32(align)), __uint8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a00b0f | _NENC_7(lane), (D4), __float32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a0070f | _NENC_7_6(lane), (D4), __poly16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a0030f | _NENC_7_5(lane), (D4), __poly8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a0070f | _NENC_7_6(lane), (D4), __int16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a00b0f | _NENC_7(lane), (D4), __int32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a0030f | _NENC_7_5(lane), (D4), __int8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a0070f | _NENC_7_6(lane), (D4), __uint16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a00b0f | _NENC_7(lane), (D4), __uint32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Dx4Adr_acc( 0xf4a0030f | _NENC_7_5(lane), (D4), __uint8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx4Adr_acc( 0xf4a00b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q4), __float32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx4Adr_acc( 0xf4a0072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q4), __poly16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx4Adr_acc( 0xf4a0072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q4), __int16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx4Adr_acc( 0xf4a00b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q4), __int32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_Qx4Adr_acc( 0xf4a0072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), (Q4), __uint16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_Qx4Adr_acc( 0xf4a00b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), (Q4), __uint32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a00b0f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN64_128(align)), (D4), __float32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a0070f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN64(align)), (D4), __poly16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a0030f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN32(align)), (D4), __poly8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a0070f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN64(align)), (D4), __int16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a00b0f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN64_128(align)), (D4), __int32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a0030f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN32(align)), (D4), __int8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a0070f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN64(align)), (D4), __uint16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a00b0f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN64_128(align)), (D4), __uint32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_Dx4Adr_acc( 0xf4a0030f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN32(align)), (D4), __uint8ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx4Adr_acc( 0xf4a00b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN64_128(align)), (Q4), __float32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx4Adr_acc( 0xf4a0072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), (Q4), __poly16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx4Adr_acc( 0xf4a0072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), (Q4), __int16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx4Adr_acc( 0xf4a00b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN64_128(align)), (Q4), __int32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_Qx4Adr_acc( 0xf4a0072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), (Q4), __uint16ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_Qx4Adr_acc( 0xf4a00b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN64_128(align)), (Q4), __uint32ToN64_c(pcD)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx_acc( 0xf2a00140 | _NENC_5(lane), (Dd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDnDmx_acc( 0xf2900040 | _NENC_5x3(lane), (Dd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx_acc( 0xf2a00040 | _NENC_5(lane), (Dd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx_acc( 0xf2a00540 | _NENC_5(lane), (Dd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDnDmx_acc( 0xf2900440 | _NENC_5x3(lane), (Dd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx_acc( 0xf2a00440 | _NENC_5(lane), (Dd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx_acc( 0xf3a00140 | _NENC_5(lane), (Qd), (Qn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdQnDmx_acc( 0xf3900040 | _NENC_5x3(lane), (Qd), (Qn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx_acc( 0xf3a00040 | _NENC_5(lane), (Qd), (Qn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx_acc( 0xf3a00540 | _NENC_5(lane), (Qd), (Qn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdQnDmx_acc( 0xf3900440 | _NENC_5x3(lane), (Qd), (Qn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx_acc( 0xf3a00440 | _NENC_5(lane), (Qd), (Qn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx_acc( 0xf2900240 | _NENC_5x3(lane), (Qd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx_acc( 0xf2a00240 | _NENC_5(lane), (Qd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx_acc( 0xf3900240 | _NENC_5x3(lane), (Qd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx_acc( 0xf3a00240 | _NENC_5(lane), (Qd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx_acc( 0xf2900640 | _NENC_5x3(lane), (Qd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx_acc( 0xf2a00640 | _NENC_5(lane), (Qd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx_acc( 0xf3900640 | _NENC_5x3(lane), (Qd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx_acc( 0xf3a00640 | _NENC_5(lane), (Qd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdFt_acc( 0xee000b10 | _NENC_21(lane), (Dd), (Ft)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdRt_acc( 0xee000b30 | _NENC_21x6(lane), (Dd), __poly16ToInt32(Rt)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_DdRt_acc( 0xee400b10 | _NENC_21x6_5(lane), (Dd), __poly8ToInt32(Rt)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdRt_acc( 0xee000b30 | _NENC_21x6(lane), (Dd), __int16ToInt32(Rt)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdRt_acc( 0xee000b10 | _NENC_21(lane), (Dd), __int32ToInt32(Rt)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_DdRt_acc( 0xee400b10 | _NENC_21x6_5(lane), (Dd), __int8ToInt32(Rt)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdRt_acc( 0xee000b30 | _NENC_21x6(lane), (Dd), __uint16ToInt32(Rt)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdRt_acc( 0xee000b10 | _NENC_21(lane), (Dd), __uint32ToInt32(Rt)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_DdRt_acc( 0xee400b10 | _NENC_21x6_5(lane), (Dd), __uint8ToInt32(Rt)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_FtDn( 0xee100b10 | _NENC_21(lane), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), (poly16_t)__neon_RtDn( 0xee900b30 | _NENC_21x6(lane), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), (poly8_t)__neon_RtDn( 0xeed00b10 | _NENC_21x6_5(lane), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), (int16_t)__neon_RtDn( 0xee100b30 | _NENC_21x6(lane), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), (int8_t)__neon_RtDn( 0xee500b10 | _NENC_21x6_5(lane), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), (int32_t)__neon_RtDn( 0xee100b10 | _NENC_21(lane), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), (uint16_t)__neon_RtDn( 0xee900b30 | _NENC_21x6(lane), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), (uint8_t)__neon_RtDn( 0xeed00b10 | _NENC_21x6_5(lane), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), (uint32_t)__neon_RtDn( 0xee100b10 | _NENC_21(lane), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 1, "invalid lane index"), __neon_DdRtRt2_acc( 0xec400b10, (Dd), __int64ToInt64(R64t)) )


text:
( __static_assert((lane) >= 0 && (lane) < 1, "invalid lane index"), __neon_DdRtRt2_acc( 0xec400b10, (Dd), __uint64ToInt64(R64t)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdRtRt2_acc( 0xec400b10 | _NENC_0(lane), (Qd), __int64ToInt64(R64t)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdRtRt2_acc( 0xec400b10 | _NENC_0(lane), (Qd), __uint64ToInt64(R64t)) )


text:
( __static_assert((lane) >= 0 && (lane) < 1, "invalid lane index"), (int64_t)__neon_RtRt2Dm( 0xec500b10, (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 1, "invalid lane index"), (uint64_t)__neon_RtRt2Dm( 0xec500b10, (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), (int64_t)__neon_RtRt2Qm( 0xec500b10 | _NENC_0(lane), (Qm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), (uint64_t)__neon_RtRt2Qm( 0xec500b10 | _NENC_0(lane), (Qm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdFt_acc( 0xee000b10 | _NENC_16((lane) >= 2 ? 1 : 0) | _NENC_21((lane) % 2), (Qd), (Ft)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_QdRt_acc( 0xee000b30 | _NENC_16((lane) >= 4 ? 1 : 0) | _NENC_21x6((lane) % 4), (Qd), __poly16ToInt32(Rt)) )


text:
( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_QdRt_acc( 0xee400b10 | _NENC_16((lane) >= 8 ? 1 : 0) | _NENC_21x6_5((lane) % 8), (Qd), __poly8ToInt32(Rt)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_QdRt_acc( 0xee000b30 | _NENC_16((lane) >= 4 ? 1 : 0) | _NENC_21x6((lane) % 4), (Qd), __int16ToInt32(Rt)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdRt_acc( 0xee000b10 | _NENC_16((lane) >= 2 ? 1 : 0) | _NENC_21((lane) % 2), (Qd), __int32ToInt32(Rt)) )


text:
( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_QdRt_acc( 0xee400b10 | _NENC_16((lane) >= 8 ? 1 : 0) | _NENC_21x6_5((lane) % 8), (Qd), __int8ToInt32(Rt)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_QdRt_acc( 0xee000b30 | _NENC_16((lane) >= 4 ? 1 : 0) | _NENC_21x6((lane) % 4), (Qd), __uint16ToInt32(Rt)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdRt_acc( 0xee000b10 | _NENC_16((lane) >= 2 ? 1 : 0) | _NENC_21((lane) % 2), (Qd), __uint32ToInt32(Rt)) )


text:
( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_QdRt_acc( 0xee400b10 | _NENC_16((lane) >= 8 ? 1 : 0) | _NENC_21x6_5((lane) % 8), (Qd), __uint8ToInt32(Rt)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_FtQn( 0xee100b10 | _NENC_16((lane) >= 2 ? 1 : 0) | _NENC_21((lane) % 2), (Qm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), (poly16_t)__neon_RtQn( 0xee900b30 | _NENC_16((lane) >= 4 ? 1 : 0) | _NENC_21x6((lane) % 4), (Qm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), (poly8_t)__neon_RtQn( 0xeed00b10 | _NENC_16((lane) >= 8 ? 1 : 0) | _NENC_21x6_5((lane) % 8), (Qm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), (int16_t)__neon_RtQn( 0xee100b30 | _NENC_16((lane) >= 4 ? 1 : 0) | _NENC_21x6((lane) % 4), (Qm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), (int8_t)__neon_RtQn( 0xee500b10 | _NENC_16((lane) >= 8 ? 1 : 0) | _NENC_21x6_5((lane) % 8), (Qm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), (int32_t)__neon_RtQn( 0xee100b10 | _NENC_16((lane) >= 2 ? 1 : 0) | _NENC_21((lane) % 2), (Qm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), (uint16_t)__neon_RtQn( 0xee900b30 | _NENC_16((lane) >= 4 ? 1 : 0) | _NENC_21x6((lane) % 4), (Qm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), (uint8_t)__neon_RtQn( 0xeed00b10 | _NENC_16((lane) >= 8 ? 1 : 0) | _NENC_21x6_5((lane) % 8), (Qm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), (uint32_t)__neon_RtQn( 0xee100b10 | _NENC_16((lane) >= 2 ? 1 : 0) | _NENC_21((lane) % 2), (Qm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx( 0xf2a00940 | _NENC_5(lane), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDnDmx( 0xf2900840 | _NENC_5x3(lane), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx( 0xf2a00840 | _NENC_5(lane), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx( 0xf3a00940 | _NENC_5(lane), (Qn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdQnDmx( 0xf3900840 | _NENC_5x3(lane), (Qn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx( 0xf3a00840 | _NENC_5(lane), (Qn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx( 0xf2900a40 | _NENC_5x3(lane), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx( 0xf2a00a40 | _NENC_5(lane), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx( 0xf3900a40 | _NENC_5x3(lane), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx( 0xf3a00a40 | _NENC_5(lane), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx_acc( 0xf2900340 | _NENC_5x3(lane), (Qd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx_acc( 0xf2a00340 | _NENC_5(lane), (Qd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx_acc( 0xf2900740 | _NENC_5x3(lane), (Qd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx_acc( 0xf2a00740 | _NENC_5(lane), (Qd), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDnDmx( 0xf2900c40 | _NENC_5x3(lane), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx( 0xf2a00c40 | _NENC_5(lane), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_DdDnDmx( 0xf2900d40 | _NENC_5x3(lane), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_DdDnDmx( 0xf2a00d40 | _NENC_5(lane), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdQnDmx( 0xf3900c40 | _NENC_5x3(lane), (Qn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx( 0xf3a00c40 | _NENC_5(lane), (Qn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdQnDmx( 0xf3900d40 | _NENC_5x3(lane), (Qn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdQnDmx( 0xf3a00d40 | _NENC_5(lane), (Qn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_QdDnDmx( 0xf2900b40 | _NENC_5x3(lane), (Dn), (Dm)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_QdDnDmx( 0xf2a00b40 | _NENC_5(lane), (Dn), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_DdDm( 0xf2900710 | _NENC_19_16(shift_amount), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_DdDm( 0xf2a00710 | _NENC_20_16(shift_amount), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_DdDm( 0xf2800790 | _NENC_21_16(shift_amount), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_DdDm( 0xf2880710 | _NENC_18_16(shift_amount), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_DdDm( 0xf3900710 | _NENC_19_16(shift_amount), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_DdDm( 0xf3a00710 | _NENC_20_16(shift_amount), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_DdDm( 0xf3800790 | _NENC_21_16(shift_amount), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_DdDm( 0xf3880710 | _NENC_18_16(shift_amount), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_DdDm( 0xf3900610 | _NENC_19_16(shift_amount), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_DdDm( 0xf3a00610 | _NENC_20_16(shift_amount), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_DdDm( 0xf3800690 | _NENC_21_16(shift_amount), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_DdDm( 0xf3880610 | _NENC_18_16(shift_amount), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_QdQm( 0xf2900750 | _NENC_19_16(shift_amount), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_QdQm( 0xf2a00750 | _NENC_20_16(shift_amount), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_QdQm( 0xf28007d0 | _NENC_21_16(shift_amount), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_QdQm( 0xf2880750 | _NENC_18_16(shift_amount), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_QdQm( 0xf3900750 | _NENC_19_16(shift_amount), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_QdQm( 0xf3a00750 | _NENC_20_16(shift_amount), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_QdQm( 0xf38007d0 | _NENC_21_16(shift_amount), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_QdQm( 0xf3880750 | _NENC_18_16(shift_amount), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_QdQm( 0xf3900650 | _NENC_19_16(shift_amount), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_QdQm( 0xf3a00650 | _NENC_20_16(shift_amount), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_QdQm( 0xf38006d0 | _NENC_21_16(shift_amount), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_QdQm( 0xf3880650 | _NENC_18_16(shift_amount), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf2880950 | _NENC_18_16(8 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf2900950 | _NENC_19_16(16 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf2a00950 | _NENC_20_16(32 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf3880950 | _NENC_18_16(8 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf3900950 | _NENC_19_16(16 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf3a00950 | _NENC_20_16(32 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf3880850 | _NENC_18_16(8 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf3900850 | _NENC_19_16(16 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf3a00850 | _NENC_20_16(32 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf2880910 | _NENC_18_16(8 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf2900910 | _NENC_19_16(16 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf2a00910 | _NENC_20_16(32 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf3880910 | _NENC_18_16(8 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf3900910 | _NENC_19_16(16 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf3a00910 | _NENC_20_16(32 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf3880810 | _NENC_18_16(8 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf3900810 | _NENC_19_16(16 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf3a00810 | _NENC_20_16(32 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_DdDm( 0xf2900510 | _NENC_19_16(shift_amount), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_DdDm( 0xf2a00510 | _NENC_20_16(shift_amount), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_DdDm( 0xf2800590 | _NENC_21_16(shift_amount), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_DdDm( 0xf2880510 | _NENC_18_16(shift_amount), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_QdQm( 0xf2900550 | _NENC_19_16(shift_amount), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_QdQm( 0xf2a00550 | _NENC_20_16(shift_amount), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_QdQm( 0xf28005d0 | _NENC_21_16(shift_amount), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_QdQm( 0xf2880550 | _NENC_18_16(shift_amount), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm( 0xf2900210 | _NENC_19_16(16 - (shift_amount)), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm( 0xf2a00210 | _NENC_20_16(32 - (shift_amount)), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm( 0xf2800290 | _NENC_21_16(64 - (shift_amount)), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm( 0xf2880210 | _NENC_18_16(8 - (shift_amount)), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm( 0xf3900210 | _NENC_19_16(16 - (shift_amount)), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm( 0xf3a00210 | _NENC_20_16(32 - (shift_amount)), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm( 0xf3800290 | _NENC_21_16(64 - (shift_amount)), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm( 0xf3880210 | _NENC_18_16(8 - (shift_amount)), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm( 0xf2900010 | _NENC_19_16(16 - (shift_amount)), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm( 0xf2a00010 | _NENC_20_16(32 - (shift_amount)), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm( 0xf2800090 | _NENC_21_16(64 - (shift_amount)), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm( 0xf2880010 | _NENC_18_16(8 - (shift_amount)), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm( 0xf3900010 | _NENC_19_16(16 - (shift_amount)), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm( 0xf3a00010 | _NENC_20_16(32 - (shift_amount)), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm( 0xf3800090 | _NENC_21_16(64 - (shift_amount)), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm( 0xf3880010 | _NENC_18_16(8 - (shift_amount)), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm( 0xf2900250 | _NENC_19_16(16 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm( 0xf2a00250 | _NENC_20_16(32 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm( 0xf28002d0 | _NENC_21_16(64 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm( 0xf2880250 | _NENC_18_16(8 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm( 0xf3900250 | _NENC_19_16(16 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm( 0xf3a00250 | _NENC_20_16(32 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm( 0xf38002d0 | _NENC_21_16(64 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm( 0xf3880250 | _NENC_18_16(8 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm( 0xf2900050 | _NENC_19_16(16 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm( 0xf2a00050 | _NENC_20_16(32 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm( 0xf28000d0 | _NENC_21_16(64 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm( 0xf2880050 | _NENC_18_16(8 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm( 0xf3900050 | _NENC_19_16(16 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm( 0xf3a00050 | _NENC_20_16(32 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm( 0xf38000d0 | _NENC_21_16(64 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm( 0xf3880050 | _NENC_18_16(8 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf2880850 | _NENC_18_16(8 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf2900850 | _NENC_19_16(16 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf2a00850 | _NENC_20_16(32 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdQm( 0xf2880810 | _NENC_18_16(8 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdQm( 0xf2900810 | _NENC_19_16(16 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdQm( 0xf2a00810 | _NENC_20_16(32 - (shift_amount)), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_DdDm_acc( 0xf3900510 | _NENC_19_16(shift_amount), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_DdDm_acc( 0xf3880510 | _NENC_18_16(shift_amount), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_DdDm_acc( 0xf3a00510 | _NENC_20_16(shift_amount), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_DdDm_acc( 0xf3800590 | _NENC_21_16(shift_amount), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 16, "invalid shift amount"), __neon_QdQm_acc( 0xf3900550 | _NENC_19_16(shift_amount), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 8, "invalid shift amount"), __neon_QdQm_acc( 0xf3880550 | _NENC_18_16(shift_amount), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 32, "invalid shift amount"), __neon_QdQm_acc( 0xf3a00550 | _NENC_20_16(shift_amount), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 0 && (shift_amount) < 64, "invalid shift amount"), __neon_QdQm_acc( 0xf38005d0 | _NENC_21_16(shift_amount), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm_acc( 0xf2900310 | _NENC_19_16(16 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm_acc( 0xf2a00310 | _NENC_20_16(32 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm_acc( 0xf2800390 | _NENC_21_16(64 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm_acc( 0xf2880310 | _NENC_18_16(8 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm_acc( 0xf3900310 | _NENC_19_16(16 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm_acc( 0xf3a00310 | _NENC_20_16(32 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm_acc( 0xf3800390 | _NENC_21_16(64 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm_acc( 0xf3880310 | _NENC_18_16(8 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm_acc( 0xf2900110 | _NENC_19_16(16 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm_acc( 0xf2a00110 | _NENC_20_16(32 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm_acc( 0xf2800190 | _NENC_21_16(64 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm_acc( 0xf2880110 | _NENC_18_16(8 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm_acc( 0xf3900110 | _NENC_19_16(16 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm_acc( 0xf3a00110 | _NENC_20_16(32 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm_acc( 0xf3800190 | _NENC_21_16(64 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm_acc( 0xf3880110 | _NENC_18_16(8 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm_acc( 0xf2900350 | _NENC_19_16(16 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm_acc( 0xf2a00350 | _NENC_20_16(32 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm_acc( 0xf28003d0 | _NENC_21_16(64 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm_acc( 0xf2880350 | _NENC_18_16(8 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm_acc( 0xf3900350 | _NENC_19_16(16 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm_acc( 0xf3a00350 | _NENC_20_16(32 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm_acc( 0xf38003d0 | _NENC_21_16(64 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm_acc( 0xf3880350 | _NENC_18_16(8 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm_acc( 0xf2900150 | _NENC_19_16(16 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm_acc( 0xf2a00150 | _NENC_20_16(32 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm_acc( 0xf28001d0 | _NENC_21_16(64 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm_acc( 0xf2880150 | _NENC_18_16(8 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm_acc( 0xf3900150 | _NENC_19_16(16 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm_acc( 0xf3a00150 | _NENC_20_16(32 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm_acc( 0xf38001d0 | _NENC_21_16(64 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm_acc( 0xf3880150 | _NENC_18_16(8 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_DdDm_acc( 0xf3900410 | _NENC_19_16(16 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_DdDm_acc( 0xf3880410 | _NENC_18_16(8 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_DdDm_acc( 0xf3a00410 | _NENC_20_16(32 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_DdDm_acc( 0xf3800490 | _NENC_21_16(64 - (shift_amount)), (Dd), (Dm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 16, "invalid shift amount"), __neon_QdQm_acc( 0xf3900450 | _NENC_19_16(16 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 8, "invalid shift amount"), __neon_QdQm_acc( 0xf3880450 | _NENC_18_16(8 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 32, "invalid shift amount"), __neon_QdQm_acc( 0xf3a00450 | _NENC_20_16(32 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert((shift_amount) >= 1 && (shift_amount) <= 64, "invalid shift amount"), __neon_QdQm_acc( 0xf38004d0 | _NENC_21_16(64 - (shift_amount)), (Qd), (Qm)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400078f | _NENC_5_4(_NEON_ALIGN64(align)), __float32ToN64(pD), (D)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400074f | _NENC_5_4(_NEON_ALIGN64(align)), __poly16ToN64(pD), (D)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400070f | _NENC_5_4(_NEON_ALIGN64(align)), __poly8ToN64(pD), (D)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400074f | _NENC_5_4(_NEON_ALIGN64(align)), __int16ToN64(pD), (D)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400078f | _NENC_5_4(_NEON_ALIGN64(align)), __int32ToN64(pD), (D)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf40007cf | _NENC_5_4(_NEON_ALIGN64(align)), __int64ToN64(pD), (D)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400070f | _NENC_5_4(_NEON_ALIGN64(align)), __int8ToN64(pD), (D)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400074f | _NENC_5_4(_NEON_ALIGN64(align)), __uint16ToN64(pD), (D)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400078f | _NENC_5_4(_NEON_ALIGN64(align)), __uint32ToN64(pD), (D)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf40007cf | _NENC_5_4(_NEON_ALIGN64(align)), __uint64ToN64(pD), (D)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrD1( 0xf400070f | _NENC_5_4(_NEON_ALIGN64(align)), __uint8ToN64(pD), (D)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a8f | _NENC_5_4(_NEON_ALIGN64_128(align)), __float32ToN64(pD), (Q)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a4f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly16ToN64(pD), (Q)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a0f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly8ToN64(pD), (Q)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a4f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int16ToN64(pD), (Q)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a8f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int32ToN64(pD), (Q)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __int64ToN64(pD), (Q)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a0f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int8ToN64(pD), (Q)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a4f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint16ToN64(pD), (Q)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a8f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint32ToN64(pD), (Q)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint64ToN64(pD), (Q)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf4000a0f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint8ToN64(pD), (Q)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrD1( 0xf480080f | _NENC_7(lane), __float32ToN64(pD), (D)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrD1( 0xf480040f | _NENC_7_6(lane), __poly16ToN64(pD), (D)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrD1( 0xf480000f | _NENC_7_5(lane), __poly8ToN64(pD), (D)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrD1( 0xf480040f | _NENC_7_6(lane), __int16ToN64(pD), (D)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrD1( 0xf480080f | _NENC_7(lane), __int32ToN64(pD), (D)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrD1( 0xf480000f | _NENC_7_5(lane), __int8ToN64(pD), (D)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrD1( 0xf480040f | _NENC_7_6(lane), __uint16ToN64(pD), (D)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrD1( 0xf480080f | _NENC_7(lane), __uint32ToN64(pD), (D)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrD1( 0xf480000f | _NENC_7_5(lane), __uint8ToN64(pD), (D)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQ1( 0xf480080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __float32ToN64(pD), (Q)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQ1( 0xf480040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __poly16ToN64(pD), (Q)) )


text:
( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_AdrQ1( 0xf480000f | _NENC_7_5((lane) % 8) | _NENC_12((lane) >= 8 ? 1 : 0), __poly8ToN64(pD), (Q)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQ1( 0xf480040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __int16ToN64(pD), (Q)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQ1( 0xf480080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __int32ToN64(pD), (Q)) )


text:
( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_AdrQ1( 0xf480000f | _NENC_7_5((lane) % 8) | _NENC_12((lane) >= 8 ? 1 : 0), __int8ToN64(pD), (Q)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQ1( 0xf480040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __uint16ToN64(pD), (Q)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQ1( 0xf480080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __uint32ToN64(pD), (Q)) )


text:
( __static_assert((lane) >= 0 && (lane) < 16, "invalid lane index"), __neon_AdrQ1( 0xf480000f | _NENC_7_5((lane) % 8) | _NENC_12((lane) >= 8 ? 1 : 0), __uint8ToN64(pD), (Q)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrD1( 0xf480080f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), __float32ToN64(pD), (D)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrD1( 0xf480040f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN16(align)), __poly16ToN64(pD), (D)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrD1( 0xf480040f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN16(align)), __int16ToN64(pD), (D)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrD1( 0xf480080f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), __int32ToN64(pD), (D)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrD1( 0xf480040f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN16(align)), __uint16ToN64(pD), (D)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrD1( 0xf480080f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), __uint32ToN64(pD), (D)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf480080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), __float32ToN64(pD), (Q)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf480040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN16(align)), __poly16ToN64(pD), (Q)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf480040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN16(align)), __int16ToN64(pD), (Q)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf480080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), __int32ToN64(pD), (Q)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf480040f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN16(align)), __uint16ToN64(pD), (Q)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrQ1( 0xf480080f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN32(align) > 0 ? 3 : 0), __uint32ToN64(pD), (Q)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf4000acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __int64ToN64(pD), (D2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf4000acf | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint64ToN64(pD), (D2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400088f | _NENC_5_4(_NEON_ALIGN64_128(align)), __float32ToN64(pD), (D2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400084f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly16ToN64(pD), (D2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400080f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly8ToN64(pD), (D2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400084f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int16ToN64(pD), (D2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400088f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int32ToN64(pD), (D2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400080f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int8ToN64(pD), (D2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400084f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint16ToN64(pD), (D2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400088f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint32ToN64(pD), (D2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx2( 0xf400080f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint8ToN64(pD), (D2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400098f | _NENC_5_4(_NEON_ALIGN64_128(align)), __float32ToN64(pD), (Q2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400094f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly16ToN64(pD), (Q2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400090f | _NENC_5_4(_NEON_ALIGN64_128(align)), __poly8ToN64(pD), (Q2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400094f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int16ToN64(pD), (Q2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400098f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int32ToN64(pD), (Q2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400090f | _NENC_5_4(_NEON_ALIGN64_128(align)), __int8ToN64(pD), (Q2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400094f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint16ToN64(pD), (Q2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400098f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint32ToN64(pD), (Q2)) )


text:
( __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx2( 0xf400090f | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint8ToN64(pD), (Q2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx2x( 0xf480090f | _NENC_7(lane), __float32ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx2x( 0xf480050f | _NENC_7_6(lane), __poly16ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx2x( 0xf480010f | _NENC_7_5(lane), __poly8ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx2x( 0xf480050f | _NENC_7_6(lane), __int16ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx2x( 0xf480090f | _NENC_7(lane), __int32ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx2x( 0xf480010f | _NENC_7_5(lane), __int8ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx2x( 0xf480050f | _NENC_7_6(lane), __uint16ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx2x( 0xf480090f | _NENC_7(lane), __uint32ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx2x( 0xf480010f | _NENC_7_5(lane), __uint8ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx2x( 0xf480094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __float32ToN64(pD), (Q2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx2x( 0xf480052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __poly16ToN64(pD), (Q2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx2x( 0xf480052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __int16ToN64(pD), (Q2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx2x( 0xf480094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __int32ToN64(pD), (Q2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx2x( 0xf480052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __uint16ToN64(pD), (Q2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx2x( 0xf480094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __uint32ToN64(pD), (Q2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480090f | _NENC_7(lane) | _NENC_4(_NEON_ALIGN64(align)), __float32ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480050f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN32(align)), __poly16ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480010f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN16(align)), __poly8ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480050f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN32(align)), __int16ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480090f | _NENC_7(lane) | _NENC_4(_NEON_ALIGN64(align)), __int32ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480010f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN16(align)), __int8ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480050f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN32(align)), __uint16ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480090f | _NENC_7(lane) | _NENC_4(_NEON_ALIGN64(align)), __uint32ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN16(align) >= 0, "invalid align"), __neon_AdrDx2x( 0xf480010f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN16(align)), __uint8ToN64(pD), (D2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx2x( 0xf480094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), __float32ToN64(pD), (Q2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrQx2x( 0xf480052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN32(align)), __poly16ToN64(pD), (Q2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrQx2x( 0xf480052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN32(align)), __int16ToN64(pD), (Q2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx2x( 0xf480094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), __int32ToN64(pD), (Q2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrQx2x( 0xf480052f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN32(align)), __uint16ToN64(pD), (Q2)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx2x( 0xf480094f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), __uint32ToN64(pD), (Q2)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf40006cf | _NENC_4(_NEON_ALIGN64(align)), __int64ToN64(pD), (D3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf40006cf | _NENC_4(_NEON_ALIGN64(align)), __uint64ToN64(pD), (D3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400048f | _NENC_4(_NEON_ALIGN64(align)), __float32ToN64(pD), (D3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400044f | _NENC_4(_NEON_ALIGN64(align)), __poly16ToN64(pD), (D3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400040f | _NENC_4(_NEON_ALIGN64(align)), __poly8ToN64(pD), (D3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400044f | _NENC_4(_NEON_ALIGN64(align)), __int16ToN64(pD), (D3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400048f | _NENC_4(_NEON_ALIGN64(align)), __int32ToN64(pD), (D3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400040f | _NENC_4(_NEON_ALIGN64(align)), __int8ToN64(pD), (D3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400044f | _NENC_4(_NEON_ALIGN64(align)), __uint16ToN64(pD), (D3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400048f | _NENC_4(_NEON_ALIGN64(align)), __uint32ToN64(pD), (D3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx3( 0xf400040f | _NENC_4(_NEON_ALIGN64(align)), __uint8ToN64(pD), (D3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400058f | _NENC_4(_NEON_ALIGN64(align)), __float32ToN64(pD), (Q3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400054f | _NENC_4(_NEON_ALIGN64(align)), __poly16ToN64(pD), (Q3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400050f | _NENC_4(_NEON_ALIGN64(align)), __poly8ToN64(pD), (Q3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400054f | _NENC_4(_NEON_ALIGN64(align)), __int16ToN64(pD), (Q3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400058f | _NENC_4(_NEON_ALIGN64(align)), __int32ToN64(pD), (Q3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400050f | _NENC_4(_NEON_ALIGN64(align)), __int8ToN64(pD), (Q3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400054f | _NENC_4(_NEON_ALIGN64(align)), __uint16ToN64(pD), (Q3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400058f | _NENC_4(_NEON_ALIGN64(align)), __uint32ToN64(pD), (Q3)) )


text:
( __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx3( 0xf400050f | _NENC_4(_NEON_ALIGN64(align)), __uint8ToN64(pD), (Q3)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx3x( 0xf4800a0f | _NENC_7(lane), __float32ToN64(pD), (D3)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx3x( 0xf480060f | _NENC_7_6(lane), __poly16ToN64(pD), (D3)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx3x( 0xf480020f | _NENC_7_5(lane), __poly8ToN64(pD), (D3)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx3x( 0xf480060f | _NENC_7_6(lane), __int16ToN64(pD), (D3)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx3x( 0xf4800a0f | _NENC_7(lane), __int32ToN64(pD), (D3)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx3x( 0xf480020f | _NENC_7_5(lane), __int8ToN64(pD), (D3)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx3x( 0xf480060f | _NENC_7_6(lane), __uint16ToN64(pD), (D3)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx3x( 0xf4800a0f | _NENC_7(lane), __uint32ToN64(pD), (D3)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx3x( 0xf480020f | _NENC_7_5(lane), __uint8ToN64(pD), (D3)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx3x( 0xf4800a4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __float32ToN64(pD), (Q3)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx3x( 0xf480062f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __poly16ToN64(pD), (Q3)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx3x( 0xf480062f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __int16ToN64(pD), (Q3)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx3x( 0xf4800a4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __int32ToN64(pD), (Q3)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx3x( 0xf480062f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __uint16ToN64(pD), (Q3)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx3x( 0xf4800a4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __uint32ToN64(pD), (Q3)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf40002cf | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int64ToN64(pD), (D4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf40002cf | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint64ToN64(pD), (D4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400008f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __float32ToN64(pD), (D4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400004f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __poly16ToN64(pD), (D4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400000f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __poly8ToN64(pD), (D4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400004f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int16ToN64(pD), (D4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400008f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int32ToN64(pD), (D4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400000f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int8ToN64(pD), (D4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400004f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint16ToN64(pD), (D4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400008f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint32ToN64(pD), (D4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrDx4( 0xf400000f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint8ToN64(pD), (D4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400018f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __float32ToN64(pD), (Q4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400014f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __poly16ToN64(pD), (Q4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400010f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __poly8ToN64(pD), (Q4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400014f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int16ToN64(pD), (Q4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400018f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int32ToN64(pD), (Q4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400010f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __int8ToN64(pD), (Q4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400014f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint16ToN64(pD), (Q4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400018f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint32ToN64(pD), (Q4)) )


text:
( __static_assert(_NEON_ALIGN64_128_256(align) >= 0, "invalid align"), __neon_AdrQx4( 0xf400010f | _NENC_5_4(_NEON_ALIGN64_128_256(align)), __uint8ToN64(pD), (Q4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx4x( 0xf4800b0f | _NENC_7(lane), __float32ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx4x( 0xf480070f | _NENC_7_6(lane), __poly16ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx4x( 0xf480030f | _NENC_7_5(lane), __poly8ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx4x( 0xf480070f | _NENC_7_6(lane), __int16ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx4x( 0xf4800b0f | _NENC_7(lane), __int32ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx4x( 0xf480030f | _NENC_7_5(lane), __int8ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrDx4x( 0xf480070f | _NENC_7_6(lane), __uint16ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __neon_AdrDx4x( 0xf4800b0f | _NENC_7(lane), __uint32ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrDx4x( 0xf480030f | _NENC_7_5(lane), __uint8ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx4x( 0xf4800b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __float32ToN64(pD), (Q4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx4x( 0xf480072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __poly16ToN64(pD), (Q4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx4x( 0xf480072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __int16ToN64(pD), (Q4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx4x( 0xf4800b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __int32ToN64(pD), (Q4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __neon_AdrQx4x( 0xf480072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0), __uint16ToN64(pD), (Q4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __neon_AdrQx4x( 0xf4800b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0), __uint32ToN64(pD), (Q4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf4800b0f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN64_128(align)), __float32ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf480070f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN64(align)), __poly16ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf480030f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN32(align)), __poly8ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf480070f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN64(align)), __int16ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf4800b0f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN64_128(align)), __int32ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf480030f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN32(align)), __int8ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf480070f | _NENC_7_6(lane) | _NENC_4(_NEON_ALIGN64(align)), __uint16ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 2, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf4800b0f | _NENC_7(lane) | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint32ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN32(align) >= 0, "invalid align"), __neon_AdrDx4x( 0xf480030f | _NENC_7_5(lane) | _NENC_4(_NEON_ALIGN32(align)), __uint8ToN64(pD), (D4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx4x( 0xf4800b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN64_128(align)), __float32ToN64(pD), (Q4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx4x( 0xf480072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), __poly16ToN64(pD), (Q4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx4x( 0xf480072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), __int16ToN64(pD), (Q4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx4x( 0xf4800b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN64_128(align)), __int32ToN64(pD), (Q4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 8, "invalid lane index"), __static_assert(_NEON_ALIGN64(align) >= 0, "invalid align"), __neon_AdrQx4x( 0xf480072f | _NENC_7_6((lane) % 4) | _NENC_12((lane) >= 4 ? 1 : 0) | _NENC_4(_NEON_ALIGN64(align)), __uint16ToN64(pD), (Q4)) )


text:
( __static_assert((lane) >= 0 && (lane) < 4, "invalid lane index"), __static_assert(_NEON_ALIGN64_128(align) >= 0, "invalid align"), __neon_AdrQx4x( 0xf4800b4f | _NENC_7((lane) % 2) | _NENC_12((lane) >= 2 ? 1 : 0) | _NENC_5_4(_NEON_ALIGN64_128(align)), __uint32ToN64(pD), (Q4)) )


text:
( (This)->lpVtbl -> Invoke(This,pvInstance,memid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) )


text:
( (This)->lpVtbl -> GetDocumentation(This,memid,pBstrName,pBstrDocString,pdwHelpContext,pBstrHelpFile) )


text:
( (This)->lpVtbl -> GetDocumentation2(This,memid,lcid,pbstrHelpString,pdwHelpStringContext,pbstrHelpStringDll) )


text:
( (This)->lpVtbl -> GetDocumentation(This,index,pBstrName,pBstrDocString,pdwHelpContext,pBstrHelpFile) )


text:
( (This)->lpVtbl -> GetDocumentation2(This,index,lcid,pbstrHelpString,pdwHelpStringContext,pbstrHelpStringDll) )


text:
( (This)->lpVtbl -> Marshal(This,pvType,dwDestContext,pvDestContext,cbBufferLength,pBuffer,pcbWritten) )


text:
( (This)->lpVtbl -> GetInfoOfIndex(This,iti,dwFlags,pptiCoClass,pdwTIFlags,pcdispidReserved,piidPrimary,piidSource) )


text:
( (This)->lpVtbl -> Draw(This,dwDrawAspect,lindex,pvAspect,ptd,hdcTargetDev,hdcDraw,lprcBounds,lprcWBounds,pfnContinue,dwContinue) )


text:
( (This)->lpVtbl -> KsProperty(This,Property,PropertyLength,PropertyData,DataLength,BytesReturned) )


text:
{ (guid)->Data1 = 0xd5a47fa7 + (USHORT)(id); (guid)->Data2 = 0x6d98; (guid)->Data3 = 0x11d1; (guid)->Data4[0] = 0xa2; (guid)->Data4[1] = 0x1a; (guid)->Data4[2] = 0x00; (guid)->Data4[3] = 0xa0; (guid)->Data4[4] = 0xc9; (guid)->Data4[5] = 0x22; (guid)->Data4[6] = 0x31; (guid)->Data4[7] = 0x96;}


text:
(((guid)->Data1 >= 0xd5a47fa7) && ((guid)->Data1 < 0xd5a47fa7 + 0xffff) && ((guid)->Data2 == 0x6d98) && ((guid)->Data3 == 0x11d1) && ((guid)->Data4[0] == 0xa2) && ((guid)->Data4[1] == 0x1a) && ((guid)->Data4[2] == 0x00) && ((guid)->Data4[3] == 0xa0) && ((guid)->Data4[4] == 0xc9) && ((guid)->Data4[5] == 0x22) && ((guid)->Data4[6] == 0x31) && ((guid)->Data4[7] == 0x96))


text:
{ (guid)->Data1 = 0xe36dc2ac + (USHORT)(id); (guid)->Data2 = 0x6d9a; (guid)->Data3 = 0x11d1; (guid)->Data4[0] = 0xa2; (guid)->Data4[1] = 0x1a; (guid)->Data4[2] = 0x00; (guid)->Data4[3] = 0xa0; (guid)->Data4[4] = 0xc9; (guid)->Data4[5] = 0x22; (guid)->Data4[6] = 0x31; (guid)->Data4[7] = 0x96;}


text:
(((guid)->Data1 >= 0xe36dc2ac) && ((guid)->Data1 < 0xe36dc2ac + 0xffff) && ((guid)->Data2 == 0x6d9a) && ((guid)->Data3 == 0x11d1) && ((guid)->Data4[0] == 0xa2) && ((guid)->Data4[1] == 0x1a) && ((guid)->Data4[2] == 0x00) && ((guid)->Data4[3] == 0xa0) && ((guid)->Data4[4] == 0xc9) && ((guid)->Data4[5] == 0x22) && ((guid)->Data4[6] == 0x31) && ((guid)->Data4[7] == 0x96))


text:
(!memcmp(((PUSHORT)&KSDATAFORMAT_SUBTYPE_WAVEFORMATEX) + 1, ((PUSHORT)(Guid)) + 1, sizeof(GUID) - sizeof(USHORT)))


text:
= {0xFF,0xC4,0x01,0xA2,0x00,0x00,0x01,0x05,0x01,0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x01,0x00,0x03,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x10,0x00,0x02,0x01,0x03,0x03,0x02,0x04,0x03,0x05,0x05,0x04,0x04,0x00,0x00,0x01,0x7D,0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xA1,0x08,0x23,0x42,0xB1,0xC1,0x15,0x52,0xD1,0xF0,0x24,0x33,0x62,0x72,0x82,0x09,0x0A,0x16,0x17,0x18,0x19,0x1A,0x25,0x26,0x27,0x28,0x29,0x2A,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0x11,0x00,0x02,0x01,0x02,0x04,0x04,0x03,0x04,0x07,0x05,0x04,0x04,0x00,0x01,0x02,0x77,0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91,0xA1,0xB1,0xC1,0x09,0x23,0x33,0x52,0xF0,0x15,0x62,0x72,0xD1,0x0A,0x16,0x24,0x34,0xE1,0x25,0xF1,0x17,0x18,0x19,0x1A,0x26,0x27,0x28,0x29,0x2A,0x35,0x36,0x37,0x38,0x39,0x3A,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA}


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_GENERAL_COMPONENTID, (Handler), sizeof(KSPROPERTY), sizeof(KSCOMPONENTID), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSMETHOD_ITEM( KSMETHOD_STREAMIO_READ, KSMETHOD_TYPE_WRITE, (Handler), sizeof(KSMETHOD), 0, NULL)


text:
DEFINE_KSMETHOD_ITEM( KSMETHOD_STREAMIO_WRITE, KSMETHOD_TYPE_READ, (Handler), sizeof(KSMETHOD), 0, NULL)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_MEDIASEEKING_CAPABILITIES, (Handler), sizeof(KSPROPERTY), sizeof(KS_SEEKING_CAPABILITIES), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_MEDIASEEKING_FORMATS, (Handler), sizeof(KSPROPERTY), 0, NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_MEDIASEEKING_TIMEFORMAT, (GetHandler), sizeof(KSPROPERTY), sizeof(GUID), (SetHandler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_MEDIASEEKING_POSITION, (Handler), sizeof(KSPROPERTY), sizeof(LONGLONG), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_MEDIASEEKING_STOPPOSITION, (Handler), sizeof(KSPROPERTY), sizeof(LONGLONG), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_MEDIASEEKING_POSITIONS, NULL, sizeof(KSPROPERTY), sizeof(KSPROPERTY_POSITIONS), (Handler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_MEDIASEEKING_DURATION, (Handler), sizeof(KSPROPERTY), sizeof(LONGLONG), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_MEDIASEEKING_AVAILABLE, (Handler), sizeof(KSPROPERTY), sizeof(KSPROPERTY_MEDIAAVAILABLE), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_MEDIASEEKING_PREROLL, (Handler), sizeof(KSPROPERTY), sizeof(LONGLONG), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_MEDIASEEKING_CONVERTTIMEFORMAT, (Handler), sizeof(KSP_TIMEFORMAT), sizeof(LONGLONG), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_TOPOLOGY_CATEGORIES, (Handler), sizeof(KSPROPERTY), 0, NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_TOPOLOGY_NODES, (Handler), sizeof(KSPROPERTY), 0, NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_TOPOLOGY_CONNECTIONS, (Handler), sizeof(KSPROPERTY), 0, NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_TOPOLOGY_NAME, (Handler), sizeof(KSP_NODE), 0, NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_TABLE(TopologySet) { DEFINE_KSPROPERTY_ITEM_TOPOLOGY_CATEGORIES(Handler), DEFINE_KSPROPERTY_ITEM_TOPOLOGY_NODES(Handler), DEFINE_KSPROPERTY_ITEM_TOPOLOGY_CONNECTIONS(Handler), DEFINE_KSPROPERTY_ITEM_TOPOLOGY_NAME(Handler)}


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_PIN_CINSTANCES, (Handler), sizeof(KSP_PIN), sizeof(KSPIN_CINSTANCES), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_PIN_CTYPES, (Handler), sizeof(KSPROPERTY), sizeof(ULONG), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_PIN_DATAFLOW, (Handler), sizeof(KSP_PIN), sizeof(KSPIN_DATAFLOW), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_PIN_DATARANGES, (Handler), sizeof(KSP_PIN), 0, NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_PIN_DATAINTERSECTION, (Handler), sizeof(KSP_PIN) + sizeof(KSMULTIPLE_ITEM), 0, NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_PIN_INTERFACES, (Handler), sizeof(KSP_PIN), 0, NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_PIN_MEDIUMS, (Handler), sizeof(KSP_PIN), 0, NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_PIN_COMMUNICATION, (Handler), sizeof(KSP_PIN), sizeof(KSPIN_COMMUNICATION), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_PIN_GLOBALCINSTANCES, (Handler), sizeof(KSP_PIN), sizeof(KSPIN_CINSTANCES), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_PIN_NECESSARYINSTANCES, (Handler), sizeof(KSP_PIN), sizeof(ULONG), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_PIN_PHYSICALCONNECTION, (Handler), sizeof(KSP_PIN), 0, NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_PIN_CATEGORY, (Handler), sizeof(KSP_PIN), sizeof(GUID), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_PIN_NAME, (Handler), sizeof(KSP_PIN), 0, NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_PIN_CONSTRAINEDDATARANGES, (Handler), sizeof(KSP_PIN), 0, NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_PIN_PROPOSEDATAFORMAT, NULL, sizeof(KSP_PIN), sizeof(KSDATAFORMAT), (Handler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_TABLE(PinSet) { DEFINE_KSPROPERTY_ITEM_PIN_CINSTANCES(PropInstances), DEFINE_KSPROPERTY_ITEM_PIN_CTYPES(PropGeneral), DEFINE_KSPROPERTY_ITEM_PIN_DATAFLOW(PropGeneral), DEFINE_KSPROPERTY_ITEM_PIN_DATARANGES(PropGeneral), DEFINE_KSPROPERTY_ITEM_PIN_DATAINTERSECTION(PropIntersection), DEFINE_KSPROPERTY_ITEM_PIN_INTERFACES(PropGeneral), DEFINE_KSPROPERTY_ITEM_PIN_MEDIUMS(PropGeneral), DEFINE_KSPROPERTY_ITEM_PIN_COMMUNICATION(PropGeneral), DEFINE_KSPROPERTY_ITEM_PIN_CATEGORY(PropGeneral), DEFINE_KSPROPERTY_ITEM_PIN_NAME(PropGeneral)}


text:
DEFINE_KSPROPERTY_TABLE(PinSet) { DEFINE_KSPROPERTY_ITEM_PIN_CINSTANCES(PropInstances), DEFINE_KSPROPERTY_ITEM_PIN_CTYPES(PropGeneral), DEFINE_KSPROPERTY_ITEM_PIN_DATAFLOW(PropGeneral), DEFINE_KSPROPERTY_ITEM_PIN_DATARANGES(PropGeneral), DEFINE_KSPROPERTY_ITEM_PIN_DATAINTERSECTION(PropIntersection), DEFINE_KSPROPERTY_ITEM_PIN_INTERFACES(PropGeneral), DEFINE_KSPROPERTY_ITEM_PIN_MEDIUMS(PropGeneral), DEFINE_KSPROPERTY_ITEM_PIN_COMMUNICATION(PropGeneral), DEFINE_KSPROPERTY_ITEM_PIN_CATEGORY(PropGeneral), DEFINE_KSPROPERTY_ITEM_PIN_NAME(PropGeneral), DEFINE_KSPROPERTY_ITEM_PIN_CONSTRAINEDDATARANGES(PropGeneral)}


text:
{ InterfacesCount, Interfaces, MediumsCount, Mediums, DataRangesCount, DataRanges, DataFlow, Communication, NULL, NULL, 0}


text:
{ InterfacesCount, Interfaces, MediumsCount, Mediums, DataRangesCount, DataRanges, DataFlow, Communication, Category, Name, 0}


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_QUALITY_REPORT, (GetHandler), sizeof(KSPROPERTY), sizeof(KSQUALITY), (SetHandler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_QUALITY_ERROR, (GetHandler), sizeof(KSPROPERTY), sizeof(KSERROR), (SetHandler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_CONNECTION_STATE, (GetHandler), sizeof(KSPROPERTY), sizeof(KSSTATE), (SetHandler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_CONNECTION_PRIORITY, (GetHandler), sizeof(KSPROPERTY), sizeof(KSPRIORITY), (SetHandler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_CONNECTION_DATAFORMAT, (GetHandler), sizeof(KSPROPERTY), 0, (SetHandler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_CONNECTION_ALLOCATORFRAMING, (Handler), sizeof(KSPROPERTY), sizeof(KSALLOCATOR_FRAMING), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_CONNECTION_ALLOCATORFRAMING_EX, (Handler), sizeof(KSPROPERTY), 0, NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_CONNECTION_PROPOSEDATAFORMAT, NULL, sizeof(KSPROPERTY), sizeof(KSDATAFORMAT), (Handler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_CONNECTION_ACQUIREORDERING, (Handler), sizeof(KSPROPERTY), sizeof(int), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_CONNECTION_STARTAT, NULL, sizeof(KSPROPERTY), sizeof(KSRELATIVEEVENT), (Handler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_MEMORY_TRANSPORT, NULL, sizeof(KSPROPERTY), sizeof(BOOL), (SetHandler), NULL, 0, NULL, NULL, 0)


text:
const KSALLOCATOR_FRAMING_EX FramingExName = { 1, 0, { 1, 1, 0 }, 0, { { MemoryType, STATIC_KS_TYPE_DONT_CARE, 0, 0, Flags, Frames, Alignment, 0, { 0, (ULONG)-1, 1 }, { { MinFrameSize, MaxFrameSize, 1 }, 0, 0 } } } }


text:
{ KsCompressionPointer->RatioNumerator = 1; KsCompressionPointer->RatioDenominator = 1; KsCompressionPointer->RatioConstantMargin = 0;}


text:
{ KsFramingRangePointer->MinFrameSize = 0; KsFramingRangePointer->MaxFrameSize = (ULONG) -1; KsFramingRangePointer->Stepping = 1;}


text:
{ KsFramingRangePointer->MinFrameSize = P_MinFrameSize; KsFramingRangePointer->MaxFrameSize = P_MaxFrameSize; KsFramingRangePointer->Stepping = 1;}


text:
{ KS_FRAMING_RANGE *KsFramingRange = &KsFramingRangeWeightedPointer->Range; SetKsFramingRange(KsFramingRange, P_MinFrameSize, P_MaxFrameSize); KsFramingRangeWeightedPointer->InPlaceWeight = 0; KsFramingRangeWeightedPointer->NotInPlaceWeight = 0;}


text:
{ KS_COMPRESSION *KsCompression = &FramingExPointer->OutputCompression; KS_FRAMING_RANGE *KsFramingRange = &FramingExPointer->FramingItem[0].PhysicalRange; KS_FRAMING_RANGE_WEIGHTED *KsFramingRangeWeighted = &FramingExPointer->FramingItem[0].FramingRange; FramingExPointer->CountItems = 1; FramingExPointer->PinFlags = 0; SetDefaultKsCompression(KsCompression); FramingExPointer->PinWeight = 0; FramingExPointer->FramingItem[0].MemoryType = P_MemoryType; FramingExPointer->FramingItem[0].BusType = KS_TYPE_DONT_CARE; FramingExPointer->FramingItem[0].MemoryFlags = 0; FramingExPointer->FramingItem[0].BusFlags = 0; FramingExPointer->FramingItem[0].Flags = P_Flags; FramingExPointer->FramingItem[0].Frames = P_Frames; FramingExPointer->FramingItem[0].FileAlignment = P_Alignment; FramingExPointer->FramingItem[0].MemoryTypeWeight = 0; SetDontCareKsFramingRange(KsFramingRange); SetKsFramingRangeWeighted(KsFramingRangeWeighted, P_MinFrameSize, P_MaxFrameSize);}


text:
DEFINE_KSMETHOD_ITEM( KSMETHOD_STREAMALLOCATOR_ALLOC, KSMETHOD_TYPE_WRITE, (Handler), sizeof(KSMETHOD), sizeof(PVOID), NULL)


text:
DEFINE_KSMETHOD_ITEM( KSMETHOD_STREAMALLOCATOR_FREE, KSMETHOD_TYPE_READ, (Handler), sizeof(KSMETHOD), sizeof(PVOID), NULL)


text:
DEFINE_KSMETHOD_TABLE(AllocatorSet) { DEFINE_KSMETHOD_ITEM_STREAMALLOCATOR_ALLOC(MethodAlloc), DEFINE_KSMETHOD_ITEM_STREAMALLOCATOR_FREE(MethodFree)}


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_STREAMALLOCATOR_FUNCTIONTABLE, (Handler), sizeof(KSPROPERTY), sizeof(KSSTREAMALLOCATOR_FUNCTIONTABLE), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_STREAMALLOCATOR_STATUS, (Handler), sizeof(KSPROPERTY), sizeof(KSSTREAMALLOCATOR_STATUS), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_TABLE(AllocatorSet) { DEFINE_KSPROPERTY_ITEM_STREAMALLOCATOR_STATUS(PropStatus), DEFINE_KSPROPERTY_ITEM_STREAMALLOCATOR_FUNCTIONTABLE(PropFunctionTable)}


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_STREAMINTERFACE_HEADERSIZE, (GetHandler), sizeof(KSPROPERTY), sizeof(ULONG), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_TABLE(StreamInterfaceSet) { DEFINE_KSPROPERTY_ITEM_STREAMINTERFACE_HEADERSIZE( HeaderSizeHandler )}


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_STREAM_ALLOCATOR, (GetHandler), sizeof(KSPROPERTY), sizeof(HANDLE), (SetHandler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_STREAM_QUALITY, (Handler), sizeof(KSPROPERTY), sizeof(KSQUALITY_MANAGER), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_STREAM_DEGRADATION, (GetHandler), sizeof(KSPROPERTY), 0, (SetHandler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_STREAM_MASTERCLOCK, (GetHandler), sizeof(KSPROPERTY), sizeof(HANDLE), (SetHandler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_STREAM_TIMEFORMAT, (Handler), sizeof(KSPROPERTY), sizeof(GUID), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_STREAM_PRESENTATIONTIME, (GetHandler), sizeof(KSPROPERTY), sizeof(KSTIME), (SetHandler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_STREAM_PRESENTATIONEXTENT, (Handler), sizeof(KSPROPERTY), sizeof(LONGLONG), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_STREAM_FRAMETIME, (Handler), sizeof(KSPROPERTY), sizeof(KSFRAMETIME), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_STREAM_RATECAPABILITY, (Handler), sizeof(KSRATE_CAPABILITY), sizeof(KSRATE), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_STREAM_RATE, (GetHandler), sizeof(KSPROPERTY), sizeof(KSRATE), (SetHandler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_STREAM_PIPE_ID, (GetHandler), sizeof(KSPROPERTY), sizeof(HANDLE), (SetHandler), NULL, 0, NULL, NULL, 0)


text:
((((ULONGLONG)(ULONG)(PerformanceTime).HighPart * NANOSECONDS / (Frequency)) << 32) + ((((((ULONGLONG)(ULONG)(PerformanceTime).HighPart * NANOSECONDS) % (Frequency)) << 32) + ((ULONGLONG)(PerformanceTime).LowPart * NANOSECONDS)) / (Frequency)))


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_CLOCK_TIME, (Handler), sizeof(KSPROPERTY), sizeof(LONGLONG), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_CLOCK_PHYSICALTIME, (Handler), sizeof(KSPROPERTY), sizeof(LONGLONG), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_CLOCK_CORRELATEDTIME, (Handler), sizeof(KSPROPERTY), sizeof(KSCORRELATED_TIME), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_CLOCK_CORRELATEDPHYSICALTIME, (Handler), sizeof(KSPROPERTY), sizeof(KSCORRELATED_TIME), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_CLOCK_RESOLUTION, (Handler), sizeof(KSPROPERTY), sizeof(KSRESOLUTION), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_CLOCK_STATE, (Handler), sizeof(KSPROPERTY), sizeof(KSSTATE), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_CLOCK_FUNCTIONTABLE, (Handler), sizeof(KSPROPERTY), sizeof(KSCLOCK_FUNCTIONTABLE), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_TABLE(ClockSet) { DEFINE_KSPROPERTY_ITEM_CLOCK_TIME(PropTime), DEFINE_KSPROPERTY_ITEM_CLOCK_PHYSICALTIME(PropPhysicalTime), DEFINE_KSPROPERTY_ITEM_CLOCK_CORRELATEDTIME(PropCorrelatedTime), DEFINE_KSPROPERTY_ITEM_CLOCK_CORRELATEDPHYSICALTIME(PropCorrelatedPhysicalTime), DEFINE_KSPROPERTY_ITEM_CLOCK_RESOLUTION(PropResolution), DEFINE_KSPROPERTY_ITEM_CLOCK_STATE(PropState), DEFINE_KSPROPERTY_ITEM_CLOCK_FUNCTIONTABLE(PropFunctionTable)}


text:
{ PropertyId, (PFNKSHANDLER)GetHandler, MinProperty, MinData, (PFNKSHANDLER)SetHandler, (PKSPROPERTY_VALUES)Values, RelationsCount, (PKSPROPERTY)Relations, (PFNKSHANDLER)SupportHandler, (ULONG)SerializedSize}


text:
{ (DispatchCreate), (PVOID)(Context), { sizeof(TypeName) - sizeof(UNICODE_NULL), sizeof(TypeName), (PWCHAR)(TypeName) }, NULL, 0}


text:
{ (DispatchCreate), (PVOID)(Context), { sizeof(TypeName) - sizeof(UNICODE_NULL), sizeof(TypeName), (PWCHAR)(TypeName) }, NULL, (Flags)}


text:
const KSDISPATCH_TABLE tablename = { DeviceIoControl, Read, Write, Flush, Close, QuerySecurity, SetSecurity, FastDeviceIoControl, FastRead, FastWrite, }


text:
STDMETHOD_(NTSTATUS, QueryInterface)(THIS_ __in REFIID InterfaceId, __deref_out PVOID* Interface ) PURE; STDMETHOD_(ULONG,AddRef)(THIS) PURE; STDMETHOD_(ULONG,Release)(THIS) PURE;


text:
KsFreeObjectCreateItemsByContext( *(KSDEVICE_HEADER *)( KsFilterFactoryGetParentDevice(FilterFactory)->FunctionalDeviceObject-> DeviceExtension), FilterFactory)


text:
_KsEdit( (Object)->Bag, (PVOID*)(PointerToPointer), sizeof(**(PointerToPointer)), sizeof(**(PointerToPointer)), (Tag))


text:
if ( pIrp->RequestorMode != KernelMode ) { pIrp->IoStatus.Information = 0; pIrp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST; if ( CompleteRequest ) IoCompleteRequest ( pIrp, IO_NO_INCREMENT ); return STATUS_INVALID_DEVICE_REQUEST; }


text:
{ (guid)->Data1 = 0x4e1cecd2 + (USHORT)(id); (guid)->Data2 = 0x1679; (guid)->Data3 = 0x463b; (guid)->Data4[0] = 0xa7; (guid)->Data4[1] = 0x2f; (guid)->Data4[2] = 0xa5; (guid)->Data4[3] = 0xbf; (guid)->Data4[4] = 0x64; (guid)->Data4[5] = 0xc8; (guid)->Data4[6] = 0x6e; (guid)->Data4[7] = 0xba;}


text:
(((guid)->Data1 >= 0x4e1cecd2) && ((guid)->Data1 < 0x4e1cecd2 + 0xffff) && ((guid)->Data2 == 0x1679) && ((guid)->Data3 == 0x463b) && ((guid)->Data4[0] == 0xa7) && ((guid)->Data4[1] == 0x2f) && ((guid)->Data4[2] == 0xa5) && ((guid)->Data4[3] == 0xbf) && ((guid)->Data4[4] == 0x64) && ((guid)->Data4[5] == 0xc8) && ((guid)->Data4[6] == 0x6e) && ((guid)->Data4[7] == 0xba))


text:
{ (guid)->Data1 = 0xabcc5a5e + (USHORT)(id); (guid)->Data2 = 0xc263; (guid)->Data3 = 0x463b; (guid)->Data4[0] = 0xa7; (guid)->Data4[1] = 0x2f; (guid)->Data4[2] = 0xa5; (guid)->Data4[3] = 0xbf; (guid)->Data4[4] = 0x64; (guid)->Data4[5] = 0xc8; (guid)->Data4[6] = 0x6e; (guid)->Data4[7] = 0xba;}


text:
(((guid)->Data1 >= 0xabcc5a5e) && ((guid)->Data1 < 0xabcc5a5e + 0xffff) && ((guid)->Data2 == 0xc263) && ((guid)->Data3 == 0x463b) && ((guid)->Data4[0] == 0xa7) && ((guid)->Data4[1] == 0x2f) && ((guid)->Data4[2] == 0xa5) && ((guid)->Data4[3] == 0xbf) && ((guid)->Data4[4] == 0x64) && ((guid)->Data4[5] == 0xc8) && ((guid)->Data4[6] == 0x6e) && ((guid)->Data4[7] == 0xba))


text:
{ (guid)->Data1 = 0XFC575048 + (USHORT)(vid); (guid)->Data2 = 0x2E08 + (USHORT)(pid); (guid)->Data3 = 0x463B + (USHORT)(strIndex); (guid)->Data4[0] = 0xA7; (guid)->Data4[1] = 0x2F; (guid)->Data4[2] = 0xA5; (guid)->Data4[3] = 0xBF; (guid)->Data4[4] = 0x64; (guid)->Data4[5] = 0xC8; (guid)->Data4[6] = 0x6E; (guid)->Data4[7] = 0xBA;}


text:
0xFC575048+(USHORT)(vid), 0x2E08+(USHORT)(pid), 0x463B+(USHORT)(strIndex), 0xA7, 0x2F, 0xA5, 0xBF, 0x64, 0xC8, 0x6E, 0xBA


text:
{ (guid)->Data1 = 0xDFF219E0 + (USHORT)(id); (guid)->Data2 = 0xF70F; (guid)->Data3 = 0x11D0; (guid)->Data4[0] = 0xb9; (guid)->Data4[1] = 0x17; (guid)->Data4[2] = 0x00; (guid)->Data4[3] = 0xa0; (guid)->Data4[4] = 0xc9; (guid)->Data4[5] = 0x22; (guid)->Data4[6] = 0x31; (guid)->Data4[7] = 0x96;}


text:
(SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT)


text:
(SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT | SPEAKER_FRONT_LEFT_OF_CENTER | SPEAKER_FRONT_RIGHT_OF_CENTER)


text:
(SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_SIDE_LEFT | SPEAKER_SIDE_RIGHT)


text:
(SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT | SPEAKER_SIDE_LEFT | SPEAKER_SIDE_RIGHT)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_DISPLAY_ADAPTER_GUID, (GetHandler), sizeof(KSPROPERTY), sizeof(GUID), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_PREFERRED_CAPTURE_SURFACE, (GetHandler), sizeof(KSPROPERTY), sizeof(CAPTURE_MEMORY_ALLOCATION_FLAGS), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_CURRENT_CAPTURE_SURFACE, (GetHandler), sizeof(KSPROPERTY), sizeof(CAPTURE_MEMORY_ALLOCATION_FLAGS), (SetHandler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_MAP_CAPTURE_HANDLE_TO_VRAM_ADDRESS, (GetHandler), sizeof(VRAM_SURFACE_INFO_PROPERTY_S), sizeof(DWORD), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_OVERLAYUPDATE_INTERESTS, (Handler), sizeof(KSPROPERTY), sizeof(ULONG), NULL, NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_OVERLAYUPDATE_PALETTE, NULL, sizeof(KSPROPERTY), 0, (Handler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_OVERLAYUPDATE_COLORKEY, NULL, sizeof(KSPROPERTY), sizeof(COLORKEY), (Handler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_OVERLAYUPDATE_CLIPLIST, NULL, sizeof(KSPROPERTY), 2 * sizeof(RECT) + sizeof(RGNDATAHEADER), (Handler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_OVERLAYUPDATE_VIDEOPOSITION, NULL, sizeof(KSPROPERTY), 2 * sizeof(RECT), (Handler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_OVERLAYUPDATE_DISPLAYCHANGE, NULL, sizeof(KSPROPERTY), sizeof(KSDISPLAYCHANGE), (Handler), NULL, 0, NULL, NULL, 0)


text:
DEFINE_KSPROPERTY_ITEM( KSPROPERTY_OVERLAYUPDATE_COLORREF, (Handler), sizeof(KSPROPERTY), sizeof(COLORREF), NULL, NULL, 0, NULL, NULL, 0)


text:
(COMP_ELEM_TYPE | COMP_ELEM_CHECKED | COMP_ELEM_DIRTY | COMP_ELEM_NOSCROLL | COMP_ELEM_POS_LEFT | COMP_ELEM_SIZE_WIDTH | COMP_ELEM_SIZE_HEIGHT | COMP_ELEM_POS_ZINDEX | COMP_ELEM_SOURCE | COMP_ELEM_FRIENDLYNAME | COMP_ELEM_POS_TOP | COMP_ELEM_SUBSCRIBEDURL | COMP_ELEM_ORIGINAL_CSI | COMP_ELEM_RESTORED_CSI | COMP_ELEM_CURITEMSTATE)


text:
{ SFV_SETITEMPOS _sip = {_pidl, {_x, _y}}; SHShellFolderView_Message(_hwnd, SFVM_SETITEMPOS, (LPARAM)(LPSFV_SETITEMPOS)&_sip);}


text:
const CConstFixedStringT<StringType, sizeof(value)/sizeof(StringType::XCHAR)> _init##name ={ {NULL, sizeof(value)/sizeof(StringType::XCHAR)-1, sizeof(value)/sizeof(StringType::XCHAR)-1, -1}, value }; const StringType::XCHAR* const _value##name = _init##name.m_achData; extern const StringType* const name = CONST_STRING_PTR(StringType, name);


text:
AFX_DEPRECATED( "This MFC feature requires /DUNICODE to work correctly, because the underlying Windows control is only supported for UNICODE builds. " "Previous versions of MFC incorrectly enabled this in ANSI/MBCS builds. " "Please compile with /DUNICODE to use this feature. See product documentation for more information." )


text:
__pragma(warning(suppress: 6255 6386)) (_MallocaComputeSize(size) != 0 ? _MarkAllocaS(malloc(_MallocaComputeSize(size)), _ALLOCA_S_HEAP_MARKER) : NULL)


text:
__pragma(warning(suppress: 6255 6386)) (_MallocaComputeSize(size) != 0 ? (((_MallocaComputeSize(size) <= _ALLOCA_S_THRESHOLD) ? _MarkAllocaS(_alloca(_MallocaComputeSize(size)), _ALLOCA_S_STACK_MARKER) : _MarkAllocaS(malloc(_MallocaComputeSize(size)), _ALLOCA_S_HEAP_MARKER))) : NULL)


text:
do { ATLTRACE(ATL::atlTraceNotImpl, 0, _T("ATL: %Ts not implemented.\n"), funcname); return E_NOTIMPL; } while(0)


text:
__ecount(1) __post __elem_readableTo(1) __post __deref __notnull __post __deref __inexpressible_writableTo(size)


text:
__deref_inout __pre __deref __inexpressible_writableTo(size) __post __deref __inexpressible_writableTo(size)


text:
__deref_inout_xcount(size) __pre __deref __inexpressible_readableTo(length) __post __deref __inexpressible_readableTo(length)


text:
__deref_inout_xcount(size) __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull


text:
__deref_inout_xcount_part(size,length) __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull


text:
__deref_inout_xcount_full(size) __pre __deref __exceptthat __maybenull __post __deref __exceptthat __maybenull


text:
__inline __nothrow void __AnalysisAssumeNullterminated(__post __nullterminated void *p) {*(char*)p=0;}


text:
( (This)->lpVtbl -> QueryBlanket(This,pProxy,pAuthnSvc,pAuthzSvc,pServerPrincName,pAuthnLevel,pImpLevel,pAuthInfo,pCapabilites) )


text:
( (This)->lpVtbl -> SetBlanket(This,pProxy,dwAuthnSvc,dwAuthzSvc,pServerPrincName,dwAuthnLevel,dwImpLevel,pAuthInfo,dwCapabilities) )


text:
( (This)->lpVtbl -> QueryBlanket(This,pAuthnSvc,pAuthzSvc,pServerPrincName,pAuthnLevel,pImpLevel,pPrivs,pCapabilities) )


text:
( (This)->lpVtbl -> AsyncGetClassBits(This,rclsid,pszTYPE,pszExt,dwFileVersionMS,dwFileVersionLS,pszCodeBase,pbc,dwClassContext,riid,flags) )


text:
( (This)->lpVtbl -> ExtractThumbnail(This,pStg,ulLength,ulHeight,pulOutputLength,pulOutputHeight,phOutputBitmap) )


text:
(((unsigned long *) rguid1)[0] == ((unsigned long *) rguid2)[0] && ((unsigned long *) rguid1)[1] == ((unsigned long *) rguid2)[1] && ((unsigned long *) rguid1)[2] == ((unsigned long *) rguid2)[2] && ((unsigned long *) rguid1)[3] == ((unsigned long *) rguid2)[3])


text:
( (This)->lpVtbl -> OnResponse(This,dwResponseCode,szResponseHeaders,szRequestHeaders,pszAdditionalRequestHeaders) )


text:
(Uri_ENCODING_USER_INFO_AND_PATH_IS_PERCENT_ENCODED_UTF8 | Uri_ENCODING_HOST_IS_PERCENT_ENCODED_UTF8 | Uri_ENCODING_QUERY_AND_FRAGMENT_IS_PERCENT_ENCODED_UTF8)


text:
( (This)->lpVtbl -> CreateUriWithFlags(This,dwCreateFlags,dwUriBuilderFlags,dwAllowEncodingPropertyMask,dwReserved,ppIUri) )


text:
( (This)->lpVtbl -> SetCacheExtension(This,pwzExt,pszCacheFile,pcbCacheFile,pdwWinInetError,pdwReserved) )


text:
( (This)->lpVtbl -> SetCacheExtension2(This,pwzExt,pwzCacheFile,pcchCacheFile,pdwWinInetError,pdwReserved) )


text:
( (This)->lpVtbl -> RegisterNameSpace(This,pCF,rclsid,pwzProtocol,cPatterns,ppwzPatterns,dwReserved) )


text:
( (This)->lpVtbl -> ParseUrl(This,pwzUrl,ParseAction,dwParseFlags,pwzResult,cchResult,pcchResult,dwReserved) )


text:
( (This)->lpVtbl -> CombineUrl(This,pwzBaseUrl,pwzRelativeUrl,dwCombineFlags,pwzResult,cchResult,pcchResult,dwReserved) )


text:
( (This)->lpVtbl -> QueryInfo(This,pwzUrl,OueryOption,dwQueryFlags,pBuffer,cbBuffer,pcbBuf,dwReserved) )


text:
( (This)->lpVtbl -> ProcessUrlAction(This,pwszUrl,dwAction,pPolicy,cbPolicy,pContext,cbContext,dwFlags,dwReserved) )


text:
( (This)->lpVtbl -> QueryCustomPolicy(This,pwszUrl,guidKey,ppPolicy,pcbPolicy,pContext,cbContext,dwReserved) )


text:
( (This)->lpVtbl -> ProcessUrlActionEx(This,pwszUrl,dwAction,pPolicy,cbPolicy,pContext,cbContext,dwFlags,dwReserved,pdwOutFlags) )


text:
( (This)->lpVtbl -> ProcessUrlActionEx2(This,pUri,dwAction,pPolicy,cbPolicy,pContext,cbContext,dwFlags,dwReserved,pdwOutFlags) )


text:
( (This)->lpVtbl -> QueryCustomPolicyEx2(This,pUri,guidKey,ppPolicy,pcbPolicy,pContext,cbContext,dwReserved) )


text:
( (This)->lpVtbl -> ProcessUrlAction(This,dwAction,pPolicy,cbPolicy,pContext,cbContext,dwFlags,dwReserved) )


text:
( (This)->lpVtbl -> QueryCustomPolicy(This,guidKey,ppPolicy,pcbPolicy,pContext,cbContext,dwReserved) )


text:
( (This)->lpVtbl -> GetZoneActionPolicyEx(This,dwZone,dwAction,pPolicy,cbPolicy,urlZoneReg,dwFlags) )


text:
( (This)->lpVtbl -> SetZoneActionPolicyEx(This,dwZone,dwAction,pPolicy,cbPolicy,urlZoneReg,dwFlags) )


text:
( (This)->lpVtbl -> GetZoneSecurityState(This,dwZoneIndex,fRespectPolicy,pdwState,pfPolicyEncountered) )


text:
( (This)->lpVtbl -> DoEncode(This,dwFlags,lInBufferSize,pbInBuffer,lOutBufferSize,pbOutBuffer,lInBytesAvailable,plInBytesRead,plOutBytesWritten,dwReserved) )


text:
( (This)->lpVtbl -> DoDecode(This,dwFlags,lInBufferSize,pbInBuffer,lOutBufferSize,pbOutBuffer,lInBytesAvailable,plInBytesRead,plOutBytesWritten,dwReserved) )


text:
DWORD dwSize; DWORD dwFlags; HINSTANCE hInstance; union { LPCSTR pszTemplate; PROPSHEETPAGE_RESOURCE pResource; } DUMMYUNIONNAME; union { HICON hIcon; LPCSTR pszIcon; } DUMMYUNIONNAME2; LPCSTR pszTitle; DLGPROC pfnDlgProc; LPARAM lParam; LPFNPSPCALLBACKA pfnCallback; UINT *pcRefParent;


text:
DWORD dwSize; DWORD dwFlags; HINSTANCE hInstance; union { LPCWSTR pszTemplate; PROPSHEETPAGE_RESOURCE pResource; } DUMMYUNIONNAME; union { HICON hIcon; LPCWSTR pszIcon; } DUMMYUNIONNAME2; LPCWSTR pszTitle; DLGPROC pfnDlgProc; LPARAM lParam; LPFNPSPCALLBACKW pfnCallback; UINT *pcRefParent;


text:
DWORD dwSize; DWORD dwFlags; HWND hwndParent; HINSTANCE hInstance; union { HICON hIcon; LPCSTR pszIcon; } DUMMYUNIONNAME; LPCSTR pszCaption; UINT nPages; union { UINT nStartPage; LPCSTR pStartPage; } DUMMYUNIONNAME2; union { LPCPROPSHEETPAGEA ppsp; HPROPSHEETPAGE *phpage; } DUMMYUNIONNAME3; PFNPROPSHEETCALLBACK pfnCallback;


text:
DWORD dwSize; DWORD dwFlags; HWND hwndParent; HINSTANCE hInstance; union { HICON hIcon; LPCWSTR pszIcon; } DUMMYUNIONNAME; LPCWSTR pszCaption; UINT nPages; union { UINT nStartPage; LPCWSTR pStartPage; } DUMMYUNIONNAME2; union { LPCPROPSHEETPAGEW ppsp; HPROPSHEETPAGE *phpage; } DUMMYUNIONNAME3; PFNPROPSHEETCALLBACK pfnCallback;


text:
( (This)->lpVtbl -> Print(This,grfFlags,pptd,ppPageSet,pstgmOptions,pcallback,nFirstPage,pcPagesPrinted,pnLastPage) )


text:
( (This)->lpVtbl -> EnumClassesOfCategories(This,cImplemented,rgcatidImpl,cRequired,rgcatidReq,ppenumClsid) )


text:
( (This)->lpVtbl -> IsClassOfCategories(This,rclsid,cImplemented,rgcatidImpl,cRequired,rgcatidReq) )


text:
(BOOL)SNDMSG((hwnd), LVM_GETITEMRECT, (WPARAM)(int)(i), ((prc) ? (((RECT *)(prc))->left = (code),(LPARAM)(RECT *)(prc)) : (LPARAM)(RECT *)NULL))


text:
(LVHT_EX_GROUP_BACKGROUND | LVHT_EX_GROUP_COLLAPSE | LVHT_EX_GROUP_FOOTER | LVHT_EX_GROUP_HEADER | LVHT_EX_GROUP_STATEICON | LVHT_EX_GROUP_SUBSETLINK)


text:
{ LV_ITEM _macro_lvi; _macro_lvi.stateMask = (mask); _macro_lvi.state = (data); SNDMSG((hwndLV), LVM_SETITEMSTATE, (WPARAM)(i), (LPARAM)(LV_ITEM *)&_macro_lvi);}


text:
{ LV_ITEM _macro_lvi; _macro_lvi.iSubItem = (iSubItem_); _macro_lvi.cchTextMax = (cchTextMax_); _macro_lvi.pszText = (pszText_); SNDMSG((hwndLV), LVM_GETITEMTEXT, (WPARAM)(i), (LPARAM)(LV_ITEM *)&_macro_lvi);}


