_to_family_map.insert(event.0.to_owned(), event.1);
    }

    for event in all_events.iter() {
        // Create the stat entry
        let mut entry = EventStat::new(event.0.to_owned(), event.1.clone(), index);
        index += 1;
        entry.pos = family_positions.get(&event.1).unwrap_or(&pt2(0.0, 0.0)).clone();
        entry.pos = entry.pos + pt2(random::<f32>() * 0.2 - 0.1, random::<f32>() * 0.2 - 0.1);

        let arc_entry = Arc::new(Mutex::new(entry));
        let event_family_stat = family_map.get_mut(&event.1).unwrap();
        let mut locked_event_family_stat = event_family_stat.lock().unwrap();
        locked_event_family_stat.children.insert(event.0.to_owned(), arc_entry);
    }

    // The main_map should now contain all of the event types pointing to all of the family maps
    (family_map, event_to_family_map)
}

#[derive(Clone, Copy)]
pub enum DensityApproach {
    Density,
    LpfDensity,
    DensityChange,
}

impl DensityApproach {
    pub fn next(&self) -> Self {
        match self {
            DensityApproach::Density => DensityApproach::LpfDensity,
            DensityApproach::LpfDensity => DensityApproach::DensityChange,
            DensityApproach::DensityChange => DensityApproach::Density
        }
    }
}

#[derive(Copy, Clone)]
pub enum SynthesisType {
    NoSynthesis,
    Frequency {freq: Sample, amp: Sample, decay: Sample },
    Bass {amp: Sample, decay: Sample, index: usize },
    Texture {index: usize, amp: Sample, decay: Sample },
    SinglePitch {index: usize, energy: Sample }
}

impl std::fmt::Display for SynthesisType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            SynthesisType::Frequency { freq, amp, decay} => write!(f, "Frequency: (freq: {}, amp: {}, decay: {})", freq, amp, decay),
            SynthesisType::Bass { amp, decay, index} => write!(f, "Bass: (amp: {}, decay: {}, index: {})", amp, decay, index),
            SynthesisType::Texture { index, amp, decay} => write!(f, "Texture: (index: {}, amp: {}, decay: {})", index, amp, decay),
            SynthesisType::SinglePitch { index, energy} => write!(f, "SinglePitch: (index: {}, energy: {})", index, energy),
            SynthesisType::NoSynthesis => write!(f, "NoSynthesis")
        }
    }
}

/// The struct for an event sent from the receiving OSC thread to the audio processing thread
pub struct EventMsg {
    /// Timestamp in samples for when this event should be played
    pub timestamp: f64,
    pub has_been_parsed: bool, /// If the event has been parsed by the audio scheduler and should be removed
    /// Other values that can be sent to the audio thread
    pub event_type: usize,
    pub pid: i32,
    pub cpu: i32,
    pub synthesis_type: Vec<SynthesisType>,
}

impl EventMsg {
    pub fn is_time(&self, time_cursor: f64) -> bool {
        if time_cursor >= self.timestamp


 *sdata;

	if (state != NETDEV_CHANGENAME)
		return NOTIFY_DONE;

	if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
		return NOTIFY_DONE;

	if (dev->ieee80211_ptr->wiphy->privid != mac80211_wiphy_privid)
		return NOTIFY_DONE;

	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	memcpy(sdata->name, dev->name, IFNAMSIZ);
	ieee80211_debugfs_rename_netdev(sdata);

	return NOTIFY_OK;
}

static struct notifier_block mac80211_netdev_notifier = {
	.notifier_call = netdev_notify,
};

int ieee80211_iface_init(void)
{
	return register_netdevice_notifier(&mac80211_netdev_notifier);
}

void ieee80211_iface_exit(void)
{
	unregister_netdevice_notifier(&mac80211_netdev_notifier);
}

void ieee80211_vif_inc_num_mcast(struct ieee80211_sub_if_data *sdata)
{
	if (sdata->vif.type == NL80211_IFTYPE_AP)
		atomic_inc(&sdata->u.ap.num_mcast_sta);
	else if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
		atomic_inc(&sdata->u.vlan.num_mcast_sta);
}

void ieee80211_vif_dec_num_mcast(struct ieee80211_sub_if_data *sdata)
{
	if (sdata->vif.type == NL80211_IFTYPE_AP)
		atomic_dec(&sdata->u.ap.num_mcast_sta);
	else if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
		atomic_dec(&sdata->u.vlan.num_mcast_sta);
}


Islands + phantagrandePage2Islands + nalhegrandePage1Islands + nalhegrandePage2Islands + oarlyegrandePage1Islands

			// Determine current island.
			var locationIndex = 0
			while (locationIndex < locationList.size) {
				val tempMapLocation: String = locationList[locationIndex]

				val tempFormattedMapLocation = tempMapLocation.lowercase().replace(" ", "_").replace("-", "_")
				if (game.imageUtils.confirmLocation("map_$tempFormattedMapLocation", tries = 1)) {
					MessageLog.printToLog("[QUEST] Bot's current location is at $tempMapLocation. Now moving to $mapName...", tag)
					currentIsland = tempMapLocation
					break
				}

				locationIndex += 1
			}

			// Now determine current skydom.
			currentSkydom = if (phantagrandePage1Islands.contains(currentIsland) || phantagrandePage2Islands.contains(currentIsland)) {
				"Phantagrande Skydom"
			} else if (nalhegrandePage1Islands.contains(currentIsland) || nalhegrandePage2Islands.contains(currentIsland)) {
				"Nalhegrande Skydom"
			} else if (oarlyegrandePage1Islands.contains(currentIsland)) {
				"Oarlyegrande Skydom"
			} else {
				throw QuestException("Current island does not fit into any of the skydoms defined.")
			}
		}

		// Once the bot has determined where it is, go to the Quest screen.
		game.findAndClickButton("quest", suppressError = true)

		game.wait(3.0)

		// Check for the "You retreated from the raid battle" popup.
		if (game.imageUtils.confirmLocation("you_retreated_from_the_raid_battle", tries = 1)) {
			game.findAndClickButton("ok")
		}

		if (game.imageUtils.confirmLocation("quest")) {
			// If the bot is currently not at the correct island, move to it.
			if (!checkLocation) {
				// Tap the "World" button.
				game.findAndClickButton("world")

				game.wait(3.0)

				// If current skydom is different from the target skydom, move to the target skydom.
				if (currentSkydom != targetSkydom) {
					exitSkydom(currentSkydom)
					enterSkydom(targetSkydom)
				}
			}

			// From the World page, move to the target island and then select the target chapter node.
			if (phantagrandePage1Islands.contains(mapName) || phantagrandePage2Islands.contains(mapName)) {
				if (!checkLocation) {
					navigateToPhantagrandeSkydomIsland(mapName, currentIsland)
					game.wait(3.0)
				}

				selectPhantagrandeChapterNode()
			} else if (nalhegrandePage1Islands.contains(mapName) || nalhegrandePage2Islands.contains(mapName)) {
				if (!checkLocation) {
					navigateToNalhegrandeSkydomIsland(mapName, currentIsland)
					game.wait(3.0)
				}

				selectNalhegrandeChapterNode()
			} else if (oarlyegrandePage1Islands.contains(mapName)) {
				if (!checkLocation) {
					navigateToOarlyegrandeSkydomIsland(mapName)
					game.wait(3.0)
				}

				selectOarlyegrandeChapterNode()
			}

			// After being on the correct chapter node, scroll down the screen as far as possible and then click the mission to start.
			MessageLog.printToLog("[QUEST] Now bringing up the Summon Selection screen for \"$missionName\"...", tag)
			game.gestureUtils.scroll()

			game.wait(2.0)

			// Now tap on the mission node to start.
			val formattedMissionName = "mission_" + missionName.lowercase().replace(" ", "_")
			if (!game.findAndClickButton(formattedMissionName)) {
				// If the bot failed to


andler)
    {
    }

    protected override ShardedChangesClientConnection CreateChangesClientConnection(WebSocket webSocket, bool throttleConnection, bool fromStudio) => new(webSocket, RequestHandler.ServerStore, RequestHandler.DatabaseContext, throttleConnection, fromStudio);

    protected override void Connect(ShardedChangesClientConnection connection)
    {
        RequestHandler.DatabaseContext.Changes.Connect(connection);
    }

    protected override void Disconnect(ShardedChangesClientConnection connection)
    {
        RequestHandler.DatabaseContext.Changes.Disconnect(connection.Id);
    }
}


         zoom: 30,
            rotationY: rotationY,
            visibleFaces: widget.visibleFaces,
          ),
          Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: <Widget>[
              Text(
                'You have pushed the button this many times:',
                style: Theme.of(context).textTheme.bodyText1.copyWith(
                    foreground: Paint()
                      ..blendMode = BlendMode.exclusion
                      ..color = Colors.white),
              ),
              Text(
                '${widget.counter}',
                style: Theme.of(context).textTheme.headline4.copyWith(
                    foreground: Paint()
                      ..blendMode = BlendMode.exclusion
                      ..color = Colors.white),
              ),
            ],
          ),
        ],
      ),
    );
  }
}

class Object3D extends StatefulWidget {
  const Object3D({
    Key key,
    @required this.path,
    @required this.zoom,
    @required this.rotationY,
    @required this.visibleFaces,
  }) : super(key: key);

  final String path;
  final double zoom;
  final Animation<double> rotationY;
  final List<Animation<double>> visibleFaces;

  @override
  _Object3DState createState() => _Object3DState();
}

class _Object3DState extends State<Object3D> {
  double angleX = 0;
  double angleZ = 0;
  double zoom = 0;

  Model model;

  @override
  void initState() {
    super.initState();
    rootBundle.loadString(widget.path).then((value) {
      setState(() {
        model = Model();
        model.loadFromString(value);
      });
    });
  }

  @override
  Widget build(BuildContext context) {
    return CustomPaint(
      painter: _ObjectPainter(
        model,
        angleX,
        widget.rotationY,
        angleZ,
        widget.zoom,
        widget.visibleFaces,
      ),
    );
  }
}

/*
 *  To render our 3D model we'll need to implement the CustomPainter interface and
 *  handle drawing to the canvas ourselves.
 *  https://api.flutter.dev/flutter/rendering/CustomPainter-class.html
 */
class _ObjectPainter extends CustomPainter {
  _ObjectPainter(
    this.model,
    this.angleX,
    this.angleY,
    this.angleZ,
    this._zoom,
    this.visibleFaces,
  )   : camera = Vector3.zero(),
        light = Vector3(0, 0, 100),
        vertices = <Vector3>[],
        super(repaint: angleY);

  double _viewPortX;
  double _viewPortY;
  final double _zoom;

  final List<Vector3> vertices;
  final Model model;
  final Vector3 camera;
  final Vector3 light;

  final double angleX;
  final Animation<double> angleY;
  final double angleZ;
  final List<Animation<double>> visibleFaces;

  Vector3 _calcVertex(Vector3 vertex) {
    final trans = Matrix4.translationValues(_viewPortX, _viewPortY, 1);
    trans.scale(_zoom, -_zoom);
    trans.rotateX(degreeToRadian(angleX));
    trans.rotateY(degreeToRadian(angleY.value));
    trans.rotateZ(degreeToRadian(angleZ));
    return trans.transform3(vertex);
  }

  void _drawFace(Canvas canvas, List<int> face, Color color) {
    // Reference the rotated vertices
    final v1 = vertices[face[0] - 1];
    final v2 = vertices[face[1] - 1];
    final v3 = vertices[face[2] - 1];

    // Calculate the surface normal
    final normalVector = normalVector3(v1, v2, v3);

    // Calculate the lighting
    final normalizedLight = Vector3.copy(light).normalized();
    final


 n26 = flags & 0xFFFDFFFF;
        int flashX = wpFlashX;
        if ((this->animLoopCount & 0x1) != 0x0) {
            n26 |= 0x20000;
            flashX = -wpFlashX;
            x = scrX - 176 - (wpIdleX + sx);
            if (b == 1) {
                x += wpIdleX - wpX;
            }
        }
        app->render->draw2DSprite(1 + weapon, b, x, y, n26, renderMode, renderFlags, 0x10000);
        if (b == 0 && (weapon == Enums::WP_BRASS_PUNCH || weapon == Enums::WP_SPIKE_PUNCH)) {
            app->render->draw2DSprite(1 + weapon, 3, x - flashX, y + wpFlashY, n26, renderMode, renderFlags, 0x10000);
        }
        int n27 = n26 & 0xFFFDFFFF;
        int n28 = scrX + (wpIdleX + sx);
        int n29 = scrY - (wpIdleY + sy);
        if ((this->animLoopCount & 0x1) == 0x0) {
            n27 |= 0x20000;
            n28 = scrX - 176 - (wpIdleX + sx);
        }
        app->render->draw2DSprite(1 + weapon, 0, n28, n29, n27, renderMode, renderFlags, 0x10000);
        if (weapon == Enums::WP_BRASS_PUNCH || weapon == Enums::WP_SPIKE_PUNCH) {
            app->render->draw2DSprite(1 + weapon, 3, n28 + flashX, n29 + wpFlashY, n27, renderMode, renderFlags, 0x10000);
        }
    }
    else if (weapon == Enums::WP_ITEM) {
        if (app->player->ammo[9] > 0) {
            app->render->draw2DSprite(app->player->activeWeaponDef->tileIndex, 1, x + wpFlashX, y + wpFlashY, flags, renderMode, renderFlags, 0x10000);
        }
        else {
            app->render->draw2DSprite(1 + weapon, 0, x, y, flags, renderMode, renderFlags, 0x10000);
        }
    }
    else if (weapon == Enums::WP_MOUNTED_GUN_TURRET) {
        app->render->draw2DSprite(Enums::TILENUM_MILITARY_CAR, 0, app->canvas->viewRect[2] / 2 - 175, app->canvas->viewRect[3] - 176, 0, 0, 0, 0x10000);
        app->render->draw2DSprite(Enums::TILENUM_MILITARY_CAR, 0, app->canvas->viewRect[2] / 2 - 1, app->canvas->viewRect[3] - 176, 0x20000, 0, 0, 0x10000);

        int v78 = ((app->gameTime - app->drivingGame->fireTime) << 8) / 300;
        int v79;
        if (v78 <= 255)
        {
            if (v78 <= 31)
            {
                wpFlashX -= 6; // [GEC]
                if (app->drivingGame->fireAngle != 0) {
                    wpFlashY -= 4; // [GEC]
                }
                app->render->draw2DSprite(Enums::TILENUM_PISTOL, 3, x + wpFlashX + /*40 old*/52 * app->drivingGame->fireAngle, wpFlashY + y, 0, 5, renderFlags, 0x8000);
            }
            v79 = -10 * v78;
        }
        else
        {
            v78 = 256;
            v79 = -2560;
        }
        app->render->draw2DSprite(Enums::TILENUM_TURRET, app->drivingGame->fireAngle & 1, x + ((10 * app->drivingGame->fireAngle * v78) >> 8), y + (v79 >> 8), (app->drivingGame->fireAngle & 2) << 16, 0, renderFlags, 0x10000);

    }
    else if (w


  if(values[i+1] != null && values[i+1].low < token.buy){
                        LogUtil.info(this.tokeName, "可以在第二日成交：" + values[i].low)
                    }

                    LogUtil.info(this.tokeName, "====================================")
                }

                counter = 0;

            }

        }

    }

    public checkSell = () => {

    }

}
export class TechSkill {
    public name:string;
    public iconName:string;

    constructor(skill:any){
        this.name = skill["name"];
        this.iconName = skill["iconName"];
    }
}/**
 * Spool Configuration
 *
 * @see {@link http://fabrixjs.io/doc/spool/config
 */
export const spool = {
  type: 'misc',
  /**
   * A searchable list of what this spool provides
   */
  provides: {
    /**
     * `resources` are the API namespaces that this spool provides
     */
    resources: [],
    /**
     * `api` is an object of keys containing arrays that declare things like:
     * api: { controllers: ['HelloWorldController'] }
     */
    api: {},
    /**
     * `config` is an array declaring the configurations included in this spool like:
     * config: ['<spoolname>', 'routes']
     */
    config: []
  },
  /**
   * Configure the lifecycle of this spool; that is, how it boots up, and which
   * order it loads relative to other spools.
   */
  lifecycle: {
    configure: {
      /**
       * List of events that must be fired before the configure lifecycle
       * method is invoked on this Spool
       */
      listen: [],

      /**
       * List of events emitted by the configure lifecycle method
       */
      emit: []
    },
    initialize: {
      listen: [],
      emit: []
    }
  }
}

import { Injectable     } from '@angular/core';
import { Observable     } from 'rxjs/Observable';
import { of             } from 'rxjs/observable/of';

import { Movie          } from '../../domainobjs/movie';
import { MessageService } from '../message/message.service';
import { HttpClient } from '@angular/common/http';
import {OmdbMovie} from '../../domainobjs/omdbmovie';

@Injectable()
export class MovieService {

  constructor(
    private http: HttpClient,
    private messageService: MessageService) { }

  static MOVIES: Movie[] = [
    {id: 0, title: 'Star Wars: Episode IV - A New Hope' , imdbID: 'tt0076759'},
    {id: 1, title: 'The Thing' , imdbID: 'tt0084787'},
    {id: 2, title: 'Ex Machina', imdbID: 'tt0470752'},
    {id: 3, title: 'Deadpool'  , imdbID: 'tt1431045'},
    {id: 4, title: 'The Game'  , imdbID: 'tt0119174'}
  ];

  static idctr = 5;

  private log(message: string) {
    this.messageService.add('MovieService: ' + message);
  }

  getMovies(): Observable<Movie[]> {
    return of(MovieService.MOVIES);
  }

  getMovie(id: number): Observable<Movie> {
    return of(MovieService.MOVIES.find(m => m.id === id));
  }

  private handleError<T>(method: string, result?: T) {
    return (error: any): Observable<T> => {

      console.error(error);
      this.log(`${method} failed: ${error.message}`);

      return of(result as T);
    };
  }

// CRUD Operations

  addMovie(movie: OmdbMovie): Observable<Movie> {
    const mov    = { id: 0, title: movie.Title, imdbID: movie.imdbID };


canist Boots
				{ 2, 16805 },	-- Felheart Gloves
				{ 3, 16829 },	-- Cenarion Boots
				{ 4, 16837 },	-- Earthfury Boots
				{ 5, 16859 },	-- Lawbringer Boots
				{ 6, 16863 },	-- Gauntlets of Might
				{ 16, 18870 },	-- Helm of the Lifegiver
				{ 17, 17109 },	-- Choker of Enlightenment
				{ 18, 19145 },	-- Robe of Volatile Power
				{ 19, 19146 },	-- Wristguards of Stability
				{ 20, 18872 },	-- Manastorm Leggings
				{ 21, 18875 },	-- Salamander Scale Pants
				{ 22, 18861 },	-- Flamewaker Legplates
				{ 23, 18879 },	-- Heavy Dark Iron Ring
				{ 24, 19147 },	-- Ring of Spell Power
				{ 25, 17077 },	-- Crimson Shocker
				{ 26, 18878 },	-- Sorcerous Dagger
				{ 30, 16665 },	-- Tome of Tranquilizing Shot
			},
		},
		{	--MCMagmadar
			name = AL["Magmadar"],
			npcID = 11982,
			Level = 999,
			DisplayIDs = {{10193}},
			AtlasMapBossID = 2,
			[NORMAL_DIFF] = {
				{ 1,  16814 },	-- Pants of Prophecy
				{ 2,  16796 },	-- Arcanist Leggings
				{ 3,  16810 },	-- Felheart Pants
				{ 4,  16822 },	-- Nightslayer Pants
				{ 5,  16835 },	-- Cenarion Leggings
				{ 6,  16847 },	-- Giantstalker's Leggings
				{ 7,  16843 },	-- Earthfury Legguards
				{ 8,  16855 },	-- Lawbringer Legplates
				{ 9,  16867 },	-- Legplates of Might
				{ 11, 18203 },	-- Eskhandar's Right Claw
				{ 16, 17065 },	-- Medallion of Steadfast Might
				{ 17, 18829 },	-- Deep Earth Spaulders
				{ 18, 18823 },	-- Aged Core Leather Gloves
				{ 19, 19143 },	-- Flameguard Gauntlets
				{ 20, 19136 },	-- Mana Igniting Cord
				{ 21, 18861 },	-- Flamewaker Legplates
				{ 22, 19144 },	-- Sabatons of the Flamewalker
				{ 23, 18824 },	-- Magma Tempered Boots
				{ 24, 18821 },	-- Quick Strike Ring
				{ 25, 18820 },	-- Talisman of Ephemeral Power
				{ 26, 19142 },	-- Fire Runed Grimoire
				{ 27, 17069 },	-- Striker's Mark
				{ 28, 17073 },	-- Earthshaker
				{ 29, 18822 },	-- Obsidian Edged Blade
			},
		},
		{	--MCGehennas
			name = AL["Gehennas"],
			npcID = 12259,
			Level = 999,
			DisplayIDs = {{13030},{12002}},
			AtlasMapBossID = 3,
			[NORMAL_DIFF] = {
				{ 1,  16812 },	-- Gloves of Prophecy
				{ 2,  16826 },	-- Nightslayer Gloves
				{ 3,  16849 },	-- Giantstalker's Boots
				{ 4,  16839 },	-- Earthfury Gauntlets
				{ 5,  16860 },	-- Lawbringer Gauntlets
				{ 6,  16862 },	-- Sabatons of Might
				{ 16, 18870 },	-- Helm of the Lifegiver
				{ 17, 19145 },	-- Robe of Volatile Power
				{ 18, 19146 },	-- Wristguards of Stability
				{ 19, 18872 },	-- Manastorm Leggings
				{ 20, 18875 },	-- Salamander Scale Pants
				{ 21, 18861 },	-- Flamewaker Legplates
				{ 22, 18879 },	-- Heavy Dark Iron Ring


glabel func_80A4C080
/* 003E0 80A4C080 8482001C */  lh      $v0, 0x001C($a0)           ## 0000001C
/* 003E4 80A4C084 848301CE */  lh      $v1, 0x01CE($a0)           ## 000001CE
/* 003E8 80A4C088 00021203 */  sra     $v0, $v0,  8
/* 003EC 80A4C08C 30420003 */  andi    $v0, $v0, 0x0003           ## $v0 = 00000000
/* 003F0 80A4C090 00021400 */  sll     $v0, $v0, 16
/* 003F4 80A4C094 04610012 */  bgez    $v1, .L80A4C0E0
/* 003F8 80A4C098 00021403 */  sra     $v0, $v0, 16
/* 003FC 80A4C09C 10400003 */  beq     $v0, $zero, .L80A4C0AC
/* 00400 80A4C0A0 24030001 */  addiu   $v1, $zero, 0x0001         ## $v1 = 00000001
/* 00404 80A4C0A4 14430008 */  bne     $v0, $v1, .L80A4C0C8
/* 00408 80A4C0A8 24010003 */  addiu   $at, $zero, 0x0003         ## $at = 00000003
.L80A4C0AC:
/* 0040C 80A4C0AC 848501CA */  lh      $a1, 0x01CA($a0)           ## 000001CA
/* 00410 80A4C0B0 240FFFFF */  addiu   $t7, $zero, 0xFFFF         ## $t7 = FFFFFFFF
/* 00414 80A4C0B4 A48F01D0 */  sh      $t7, 0x01D0($a0)           ## 000001D0
/* 00418 80A4C0B8 24AEFFFF */  addiu   $t6, $a1, 0xFFFF           ## $t6 = FFFFFFFF
/* 0041C 80A4C0BC A48E01CE */  sh      $t6, 0x01CE($a0)           ## 000001CE
/* 00420 80A4C0C0 03E00008 */  jr      $ra
/* 00424 80A4C0C4 A48501CC */  sh      $a1, 0x01CC($a0)           ## 000001CC
.L80A4C0C8:
/* 00428 80A4C0C8 14410018 */  bne     $v0, $at, .L80A4C12C
/* 0042C 80A4C0CC 00000000 */  nop
/* 00430 80A4C0D0 A48001CC */  sh      $zero, 0x01CC($a0)         ## 000001CC
/* 00434 80A4C0D4 A48301CE */  sh      $v1, 0x01CE($a0)           ## 000001CE
/* 00438 80A4C0D8


},
ET:function ET(){},
a9j:function(a){var u,t,s
switch(a.x){case C.aW:u=a.c
t=u!=null?new X.c0(u.gho(u)):C.cW
break
case C.S:u=a.d
t=a.c
if(u!=null){s=t==null?null:t.gho(t)
t=new X.bJ(s==null?C.r:s,u)}else if(t==null)t=C.qc
break
default:t=null}return new V.jI(a.a,a.f,a.b,a.e,t)},
RF:function(a,b,c){var u,t,s,r,q,p=null,o=a==null
if(o&&b==null)return
if(!o&&b!=null){if(c===0)return a
if(c===1)return b}u=o?p:a.a
t=b==null
u=P.F(u,t?p:b.a,c)
s=o?p:a.b
s=T.a8j(s,t?p:b.b,c)
r=c<0.5?a.c:b.c
q=o?p:a.d
q=O.a4R(q,t?p:b.d,c)
o=o?p:a.e
return new V.jI(u,s,r,q,Y.eV(o,t?p:b.e,c))},
jI:function jI(a,b,c,d,e){var _=this
_.a=a
_.b=b
_.c=c
_.d=d
_.e=e},
a1f:function a1f(a,b){var _=this
_.b=a
_.Q=_.z=_.y=_.x=_.r=_.f=_.e=_.d=_.c=null
_.a=b},
a9a:function(a,b){var u,t,s,r,q,p,o,n,m,l,k,j,i={}
i.a=b
if(a==null)a=C.jy
if(b==null)b=C.jx
i.a=b
u=J.bl(b)-1
t=a.length-1
s=new Array(J.bl(b))
s.fixed$length=Array
r=A.bB
q=H.c(s,[r])
p=0<=t
s=0<=u
while(!0){if(!(p&&s))break
o=a[0]
n=J.aj(b,0)
o.d
C.cc.gnq(n)
break}while(!0){if(!(p&&s))break
o=a[t]
m=J.aj(b,u)
o.d
C.cc.gnq(m)
break}if(p){l=P.t(D.d8,r)
for(k=0;k<=t;){a[k].d;++k}p=!0}else{k=0
l=null}for(j=0;j<=u;){n=J.aj(i.a,j)
if(p){o=l.i(0,C.cc.gnq(n))
if(o!=null){n.gnq(n)
o=null}}else o=null
q[j]=V.a99(o,n);++j}s=i.a
u=J.bl(s)-1
t=a.length-1
while(!0){if(!(k<=t&&j<=u))break
q[j]=V.a99(a[k],J.aj(s,j));++j;++k}return q},
a99:function(a,b){var u,t,s,r,q,p,o,n,m,l,k,j,i,h,g,f,e,d
if(a==null){u=C.cc.gnq(b)
t=$.mS()


#pragma once

#include <memory>
#include <string>

#include <agui/agui.h>
#include <agui/gui/events/fwd-agui.h>
#include <agui/gui/events/GUIActionListener.h>
#include <agui/gui/events/GUIChangeListener.h>
#include <agui/gui/events/GUIFocusListener.h>
#include <agui/gui/events/GUITooltipRequestListener.h>
#include <agui/gui/nodes/fwd-agui.h>

#include <tdme/tdme.h>
#include <tdme/tools/editor/controllers/ScreenController.h>
#include <tdme/tools/editor/misc/fwd-tdme.h>
#include <tdme/utilities/fwd-tdme.h>

using std::string;
using std::unique_ptr;

using agui::gui::events::GUIActionListener;
using agui::gui::events::GUIActionListenerType;
using agui::gui::events::GUIChangeListener;
using agui::gui::events::GUIFocusListener;
using agui::gui::events::GUITooltipRequestListener;
using agui::gui::nodes::GUIElementNode;
using agui::gui::nodes::GUINode;
using agui::gui::nodes::GUIScreenNode;

using tdme::tools::editor::controllers::ScreenController;
using tdme::tools::editor::misc::PopUps;
using tdme::utilities::Action;

/**
 * Input dialog screen controller
 * @author Andreas Drewke
 */
class tdme::tools::editor::controllers::InputDialogScreenController final
	: public ScreenController
	, public GUIActionListener
	, public GUIChangeListener
	, public GUIFocusListener
	, public GUITooltipRequestListener
{

private:
	PopUps* popUps { nullptr };
	GUIScreenNode* screenNode { nullptr };
	GUIElementNode* tabsHeaderNode { nullptr };
	GUIElementNode* inputNode { nullptr };
	unique_ptr<Action> applyAction;
	unique_ptr<Action> cancelAction;

public:
	// forbid class copy
	FORBID_CLASS_COPY(InputDialogScreenController)

	/**
	 * Public constructor
	 * @param popUps pop ups
	 */
	InputDialogScreenController(PopUps* popUps);

	/**
	 * Destructor
	 */
	virtual ~InputDialogScreenController();

	// overridden methods
	GUIScreenNode* getScreenNode() override;

	/**
	 * @returns input text
	 */
	const string getInputText();

	/**
	 * Shows the input dialog pop up
	 * @param captionText caption text
	 * @param inputText input text
	 * @param applyAction apply action
	 * @param cancelAction cancel action
	 */
	void show(const string& captionText, const string& inputText, Action* applyAction, Action* cancelAction = nullptr);

	/**
	 * Abort the file dialog pop up
	 */
	void close();

	// overridden methods
	void initialize() override;
	void dispose() override;
	void onChange(GUIElementNode* node) override;
	void onAction(GUIActionListenerType type, GUIElementNode* node) override;
	void onFocus(GUIElementNode* node) override;
	void onUnfocus(GUIElementNode* node) override;
	void onTooltipShowRequest(GUINode* node, int mouseX, int mouseY) override;
	void onTooltipCloseRequest() override;

};


videoDetailCtr.tabCtr.animateTo(1),
                  selectStatus: false,
                  text: widget.bangumiDetail!.stat!['reply']!.toString(),
                ),
                ActionItem(
                  icon: const Icon(FontAwesomeIcons.shareFromSquare),
                  onTap: () => bangumiIntroController.actionShareVideo(),
                  selectStatus: false,
                  text: widget.bangumiDetail!.stat!['share']!.toString(),
                ),
              ],
            ),
          ),
        ),
      );
    });
  }
}
import 'dart:math';
import 'dart:typed_data';
import 'dart:ui';
import 'package:flutter/material.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter_smart_dialog/flutter_smart_dialog.dart';
import 'package:get/get.dart';
import 'package:pilipala/models/video/reply/item.dart';
import 'package:pilipala/pages/video/detail/reply/widgets/reply_item.dart';
import 'package:saver_gallery/saver_gallery.dart';

class ReplySave extends StatefulWidget {
  final ReplyItemModel? replyItem;
  const ReplySave({required this.replyItem, super.key});

  @override
  State<ReplySave> createState() => _ReplySaveState();
}

class _ReplySaveState extends State<ReplySave> {
  final _boundaryKey = GlobalKey();

  void _generatePicWidget() async {
    SmartDialog.showLoading(msg: '保存中');
    try {
      RenderRepaintBoundary boundary = _boundaryKey.currentContext!
          .findRenderObject() as RenderRepaintBoundary;
      var image = await boundary.toImage(pixelRatio: 3);
      ByteData? byteData = await image.toByteData(format: ImageByteFormat.png);
      Uint8List pngBytes = byteData!.buffer.asUint8List();
      String picName =
          "plpl_reply_${DateTime.now().toString().replaceAll(RegExp(r'[- :]'), '').split('.').first}";
      final result = await SaverGallery.saveImage(
        Uint8List.fromList(pngBytes),
        name: '$picName.png',
        androidRelativePath: "Pictures/PiliPala",
        androidExistNotSave: false,
      );
      if (result.isSuccess) {
        SmartDialog.showToast('保存成功');
      }
    } catch (err) {
      print(err);
    } finally {
      SmartDialog.dismiss();
    }
  }

  List<Widget> _createWidgets(int count, Widget Function() builder) {
    return List<Widget>.generate(count, (_) => Expanded(child: builder()));
  }

  List<Widget> _createColumnWidgets() {
    return _createWidgets(3, () => Row(children: _createRowWidgets()));
  }

  List<Widget> _createRowWidgets() {
    return _createWidgets(
      4,
      () => Center(
        child: Transform.rotate(
          angle: pi / 10,
          child: const Text(
            'PiliPala',
            style: TextStyle(
              color: Color(0x08000000),
              fontSize: 18,
              fontWeight: FontWeight.bold,
              decoration: TextDecoration.none,
            ),
          ),
        ),
      ),
    );
  }

  @override
  Widget build(BuildContext context) {
    return SafeArea(
      top: false,
      bottom: false,
      child: BackdropFilter(
        filter: ImageFilter.blur(sigmaX: 4.0, sigmaY: 4.0),
        child: Container(
          width: Get.width,
          height: Get.height,
          padding: EdgeInsets.fromLTRB(
            0,
            MediaQuery.of(context).padding.top + 4,
            0,
            MediaQuery.of(context).padding.bottom + 4,
          ),
          color: Colors.black54,
          child: Column(
            children: [
              Expanded(
                child: Container(
                  clipBehavior: Clip.antiAlias,
                  decoration: BoxDecoration(
                    borderRadius: BorderRadius.circular(20),
                  ),
                  child: Center(
                    child: SingleChildScrollView(
                      child: RepaintBoundary


� (66-20)
        cp[4677] = 0x76D6; // 盖 (66-21)
        cp[4678] = 0x76D2; // 盒 (66-22)
        cp[4679] = 0x76DE; // 盞 (66-23)
        cp[4680] = 0x76E1; // 盡 (66-24)
        cp[4681] = 0x76E5; // 盥 (66-25)
        cp[4682] = 0x76E7; // 盧 (66-26)
        cp[4683] = 0x76EA; // 盪 (66-27)
        cp[4684] = 0x862F; // 蘯 (66-28)
        cp[4685] = 0x76FB; // 盻 (66-29)
        cp[4686] = 0x7708; // 眈 (66-30)
        cp[4687] = 0x7707; // 眇 (66-31)
        cp[4688] = 0x7704; // 眄 (66-32)
        cp[4689] = 0x7729; // 眩 (66-33)
        cp[4690] = 0x7724; // 眤 (66-34)
        cp[4691] = 0x771E; // 眞 (66-35)
        cp[4692] = 0x7725; // 眥 (66-36)
        cp[4693] = 0x7726; // 眦 (66-37)
        cp[4694] = 0x771B; // 眛 (66-38)
        cp[4695] = 0x7737; // 眷 (66-39)
        cp[4696] = 0x7738; // 眸 (66-40)
        cp[4697] = 0x7747; // 睇 (66-41)
        cp[4698] = 0x775A; // 睚 (66-42)
        cp[4699] = 0x7768; // 睨 (66-43)
        cp[4700] = 0x776B; // 睫 (66-44)
        cp[4701] = 0x775B; // 睛 (66-45)
        cp[4702] = 0x7765; // 睥 (66-46)
        cp[4703] = 0x777F; // 睿 (66-47)
        cp[4704] = 0x777E; // 睾 (66-48)
        cp[4705] = 0x7779; // 睹 (66-49)
        cp[4706] = 0x778E; // 瞎 (66-50)
        cp[4707] = 0x778B; // 瞋 (66-51)
        cp[4708] = 0x7791; // 瞑 (66-52)
        cp[4709] = 0x77A0; // 瞠 (66-53)
        cp[4710] = 0x779E; // 瞞 (66-54)
        cp[4711] = 0x77B0; // 瞰 (66-55)
        cp[4712] = 0x77B6; // 瞶 (66-56)
        cp[4713] = 0x77B9; // 瞹 (66-57)
        cp[4714] = 0x77BF; // 瞿 (66-58)
        cp[4715] = 0x77BC; // 瞼 (66-59)
        cp[4716] = 0x77BD; // 瞽 (66-60)
        cp[4717] = 0x77BB; // 瞻 (66-61)
        cp[4718] = 0x77C7; // 矇 (66-62)
        cp[4719] = 0x77CD; // 矍 (66-63)
        cp[4720] = 0x77D7; // 矗 (66-64)


Slice[string]
	value.MustParse([]string{"apple", "banana", "cherry"})
	fmt.Println(value.Get())

	// Duplicate values will fail
	var invalidValue required.UniqueSlice[string]
	err := invalidValue.Parse([]string{"apple", "banana", "apple"})
	fmt.Println("Duplicate value error:", err != nil)

	// Output:
	// [apple banana cherry]
	// Duplicate value error: true
}

func ExampleNonEmpty() {
	// NonEmpty with a slice type
	var value required.NonEmpty[[]string, string]
	value.MustParse([]string{"hello", "world"})
	fmt.Println(value.Get())

	// Empty slices will fail
	var invalidValue required.NonEmpty[[]string, string]
	err := invalidValue.Parse([]string{})
	fmt.Println("Empty slice error:", err != nil)

	// Output:
	// [hello world]
	// Empty slice error: true
}

func ExampleNonEmptySlice() {
	// NonEmptySlice is a simplified version of NonEmpty
	var value required.NonEmptySlice[int]
	value.MustParse([]int{1, 2, 3})
	fmt.Println(value.Get())

	// Empty slices will fail
	var invalidValue required.NonEmptySlice[int]
	err := invalidValue.Parse([]int{})
	fmt.Println("Empty slice error:", err != nil)

	// Output:
	// [1 2 3]
	// Empty slice error: true
}

func ExampleMIME() {
	var value required.MIME[string]
	value.MustParse("text/html")
	fmt.Println(value.Get())

	value.MustParse("application/json")
	fmt.Println(value.Get())

	value.MustParse("image/png")
	fmt.Println(value.Get())

	// Invalid MIME types will fail
	var invalidValue required.MIME[string]
	err := invalidValue.Parse("not a mime type")
	fmt.Println("Invalid MIME type error:", err != nil)

	// Output:
	// text/html
	// application/json
	// image/png
	// Invalid MIME type error: true
}

func ExampleUUID() {
	var value required.UUID[string]
	value.MustParse("550e8400-e29b-41d4-a716-446655440000")
	fmt.Println(value.Get())

	// Different UUID formats are accepted
	value.MustParse("urn:uuid:550e8400-e29b-41d4-a716-446655440000")
	fmt.Println("URN format accepted")

	value.MustParse("550e8400e29b41d4a716446655440000")
	fmt.Println("No hyphens format accepted")

	value.MustParse("{550e8400-e29b-41d4-a716-446655440000}")
	fmt.Println("Braces format accepted")

	// Invalid UUIDs will fail
	var invalidValue required.UUID[string]
	err := invalidValue.Parse("not-a-uuid")
	fmt.Println("Invalid UUID error:", err != nil)

	err = invalidValue.Parse("550e8400-e29b-41d4-a716-44665544000") // too short
	fmt.Println("Too short UUID error:", err != nil)

	// Output:
	// 550e8400-e29b-41d4-a716-446655440000
	// URN format accepted
	// No hyphens format accepted
	// Braces format accepted
	// Invalid UUID error: true
	// Too short UUID error: true
}

func ExampleJSON() {
	var value required.JSON[string]
	value.MustParse(`{"name": "John", "age": 30}`)
	fmt.Println(value.Get())

	value.MustParse(`[1, 2, 3, 4, 5]`)
	fmt.Println(value.Get())

	value.MustParse(`"simple string"`)
	fmt.Println(value.Get())

	// Invalid JSON will fail
	var invalidValue required.


ube.js/issues/1515) [#1612](https://github.com/cube-js/cube.js/issues/1612)
- **@cubejs-client/react:** dry run hook ([#1612](https://github.com/cube-js/cube.js/issues/1612)) ([9aea035](https://github.com/cube-js/cube.js/commit/9aea03556ae61f443598ed587538e60239a3be2d))

## [0.24.8](https://github.com/cube-js/cube.js/compare/v0.24.7...v0.24.8) (2020-12-15)

### Bug Fixes

- **@cubejs-backend/mysql-driver:** Use decimal(38,10) for external pre-aggregations, fix [#1563](https://github.com/cube-js/cube.js/issues/1563) ([3aec549](https://github.com/cube-js/cube.js/commit/3aec549f0344590185618427b854eef863d24287))
- **@cubejs-backend/schema-compiler:** CubeCheckDuplicatePropTranspiler - dont crash on not StringLiterals ([#1582](https://github.com/cube-js/cube.js/issues/1582)) ([a705a2e](https://github.com/cube-js/cube.js/commit/a705a2ed6885d5c08e654945682054a1421dfb51))
- **@cubejs-client/playground:** fix color name and change font to Inter ([010a106](https://github.com/cube-js/cube.js/commit/010a106442dfc39a2027733d5087ac6b7e2cdcb3))

### Features

- **@cubejs-backend/query-orchestrator:** Introduce AsyncRedisClient type ([728110e](https://github.com/cube-js/cube.js/commit/728110ed0ffe5697bd5e47e3920bf2e5377a0ffd))
- **@cubejs-backend/query-orchestrator:** Migrate createRedisClient to TS ([78e8422](https://github.com/cube-js/cube.js/commit/78e8422937e79457fdcec70535225bc9ccecfce8))
- **@cubejs-backend/query-orchestrator:** Move RedisPool to TS, export RedisPoolOptions ([8e8abde](https://github.com/cube-js/cube.js/commit/8e8abde85b9fa821d21f33fc286cfb2cc56891e4))
- **@cubejs-backend/query-orchestrator:** Set redis pool options from server config ([c1270d4](https://github.com/cube-js/cube.js/commit/c1270d4cfdc243b230ade0cb3a4c59171db70d20))
- **@cubejs-client/core:** Added pivotConfig option to alias series with a prefix ([#1594](https://github.com/cube-js/cube.js/issues/1594)). Thanks to @MattGson! ([a3342f7](https://github.com/cube-js/cube.js/commit/a3342f7fd0389ce3ad0bc62686c0e787de25f411))
- Set CUBEJS_SCHEDULED_REFRESH_TIMER default value to 30 seconds ([f69324c](https://github.com/cube-js/cube.js/commit/f69324c60ee4adfdfded67dddedab113fb5fdb95))

## [0.24.7](https://github.com/cube-js/cube.js/compare/v0.24.6...v0.24.7) (2020-12-14)

### Bug Fixes

- **@cubejs-backend/mysql-driver:** Do not validate connections in pool and expos


%lo(D_801D90D8)
/* 20A49C 801DF93C AD48008C */  sw          $t0, 0x8C($t2)
.L801DF940:
/* 20A4A0 801DF940 8E0E0000 */  lw          $t6, 0x0($s0)
/* 20A4A4 801DF944 3C0B800E */  lui         $t3, %hi(D_800DFBD0)
/* 20A4A8 801DF948 00002825 */  move        $a1, $zero
/* 20A4AC 801DF94C 8DCF0000 */  lw          $t7, 0x0($t6)
/* 20A4B0 801DF950 00003025 */  move        $a2, $zero
/* 20A4B4 801DF954 000FC880 */  sll         $t9, $t7, 2
/* 20A4B8 801DF958 01795821 */  addu        $t3, $t3, $t9
/* 20A4BC 801DF95C 8D6BFBD0 */  lw          $t3, %lo(D_800DFBD0)($t3)
/* 20A4C0 801DF960 0C07861A */  jal         func_801E1868_ovl15
/* 20A4C4 801DF964 8D640018 */   lw         $a0, 0x18($t3)
/* 20A4C8 801DF968 8E0D0000 */  lw          $t5, 0x0($s0)
/* 20A4CC 801DF96C 3C0C800F */  lui         $t4, %hi(D_800E83E0)
/* 20A4D0 801DF970 24010001 */  addiu       $at, $zero, 0x1
/* 20A4D4 801DF974 8DA20000 */  lw          $v0, 0x0($t5)
/* 20A4D8 801DF978 3C18800E */  lui         $t8, %hi(gEntityVtableIndexArray)
/* 20A4DC 801DF97C 00021080 */  sll         $v0, $v0, 2
/* 20A4E0 801DF980 01826021 */  addu        $t4, $t4, $v0
/* 20A4E4 801DF984 8D8C83E0 */  lw          $t4, %lo(D_800E83E0)($t4)
/* 20A4E8 801DF988 0302C021 */  addu        $t8, $t8, $v0
/* 20A4EC 801DF98C 15810007 */  bne         $t4, $at, .L801DF9AC
/* 20A4F0 801DF990 00000000 */   nop
/* 20A4F4 801DF994 8F18DC50 */  lw          $t8, %lo(gEntityVtableIndexArray)($t8)
/* 20A4F8 801DF998 24010010 */  addiu       $at, $zero, 0x10
/* 20A4FC 801DF99C 13010003 */  beq         $t8, $at, .L801DF9AC
/* 20A500 801DF9A0 00000000 */   nop
/* 20A504 801DF9A4 0C077D04 */  jal         func_801DF410_ovl15
/* 20A508 801DF9A8 8FA40020 */   lw         $a0, 0x20($sp)
.L801DF9AC:
/* 20A50C 801DF9AC 0C078708 */  jal         func_801E1C20_ovl15
/* 20A510 801DF9B0 8FA40020 */   lw         $a0, 0x20($sp)
/* 20A514 801DF9B4 8FBF001C */  lw          $ra, 0x1C($sp)
/* 20A518 801DF9B8 8FB00018 */  lw          $s0, 0x18($sp)
/* 20A51C 801DF9BC 27BD0020 */  addiu       $sp, $sp, 0


en',
		value		: 'Wert',
		size		: 'Größe',
		lines		: 'Linien',
		chkMulti	: 'Erlaube Mehrfachauswahl',
		opText		: 'Text',
		opValue		: 'Wert',
		btnAdd		: 'Hinzufügen',
		btnModify	: 'Ändern',
		btnUp		: 'Hoch',
		btnDown		: 'Runter',
		btnSetValue : 'Setze als Standardwert',
		btnDelete	: 'Entfernen'
	},

	// Textarea Dialog.
	textarea :
	{
		title		: 'Textfeld (mehrzeilig) Eigenschaften',
		cols		: 'Spalten',
		rows		: 'Reihen'
	},

	// Text Field Dialog.
	textfield :
	{
		title		: 'Textfeld (einzeilig) Eigenschaften',
		name		: 'Name',
		value		: 'Wert',
		charWidth	: 'Zeichenbreite',
		maxChars	: 'Max. Zeichen',
		type		: 'Typ',
		typeText	: 'Text',
		typePass	: 'Passwort'
	},

	// Hidden Field Dialog.
	hidden :
	{
		title	: 'Verstecktes Feld-Eigenschaften',
		name	: 'Name',
		value	: 'Wert'
	},

	// Image Dialog.
	image :
	{
		title		: 'Bild-Eigenschaften',
		titleButton	: 'Bildbutton-Eigenschaften',
		menu		: 'Bild-Eigenschaften',
		infoTab		: 'Bild-Info',
		btnUpload	: 'Zum Server senden',
		upload		: 'Hochladen',
		alt			: 'Alternativer Text',
		width		: 'Breite',
		height		: 'Höhe',
		lockRatio	: 'Größenverhältnis beibehalten',
		unlockRatio	: 'Ratio Freischalten',
		resetSize	: 'Größe zurücksetzen',
		border		: 'Rahmen',
		hSpace		: 'Horizontal-Abstand',
		vSpace		: 'Vertikal-Abstand',
		align		: 'Ausrichtung',
		alignLeft	: 'Links',
		alignRight	: 'Rechts',
		alertUrl	: 'Bitte geben Sie die Bild-URL an',
		linkTab		: 'Link',
		button2Img	: 'Möchten Sie den gewählten Bild-Button in ein einfaches Bild umwandeln?',
		img2Button	: 'Möchten Sie das gewählten Bild in einen Bild-Button umwandeln?',
		urlMissing	: 'Imagequelle URL fehlt.',
		validateWidth	: 'Breite muß eine ganze Zahl sein.',
		validateHeight	: 'Höhe muß eine ganze Zahl sein.',
		validateBorder	: 'Rahmen muß eine ganze Zahl sein.',
		validateHSpace	: 'Horizontal-Abstand muß eine ganze Zahl sein.',
		validateVSpace	: 'Vertikal-Abstand must be a whole number.'
	},

	// Flash Dialog
	flash :
	{
		properties		: 'Flash-Eigenschaften',
		propertiesTab	: 'Eigenschaften',
		title			: 'Flash-Eigenschaften',
		chkPlay			: 'autom. Abspielen',
		chkLoop			: 'Endlosschleife',
		chkMenu			: 'Flash-Menü aktivieren',
		chkFull			: 'Vollbildmodus erlauben',
 		scale			: 'Skalierung',
		scaleAll		: 'Alles anzeigen',
		scaleNoBorder	: 'ohne Rand',
		scaleFit		: 'Passgenau',
		access			: 'Skript Zugang',
		accessAlways	: 'Immer',
		accessSameDomain: 'Gleiche


>\noptimi zed</w>\noc c</w>\nmi wx</w>\nen ka</w>\nel ited\nafford able\nsa kh</w>\ncoron ado</w>\nho h</w>\nat ul</w>\nai oli</w>\njim cantore</w>\naccoun ted</w>\nvin ay\nher mit</w>\ngroo ves</w>\nran ch\nr illa\nwe tter</w>\nou tof\nveter in\nni kov</w>\nki an\nfair banks</w>\nram apho\nn iti\nk ko</w>\nru sty\nne stle</w>\ntv xq</w>\nshahe er</w>\nâĿ¤âĿ¤ âĿ¤âĿ¤</w>\npenn ant</w>\ngem stones</w>\ndem debate</w>\nðŁĲ Ĭ</w>\nauton ews</w>\nsupport indiefilm</w>\nmach o</w>\nve x</w>\nnew sat</w>\nne ti\nconce ssions</w>\ncan died</w>\nyof the\nmac au\nden ds</w>\ncricke ters</w>\nsan iti\nmari ano</w>\ngh at</w>\nar toftheday</w>\n¡ ľ\ne gos</w>\ngen oa</w>\nchat bots</w>\nbri er</w>\nal labout\nmon ty\nspi ed</w>\nr tr</w>\ncomfor t\nsni ppets</w>\nreal time\ngra in\nexam ined</w>\nen lightening</w>\ntt u</w>\ngod bless</w>\nrelease the\nsing ular</w>\nki ans</w>\nha ka</w>\nsor ren\ndefe ct</w>\nmar g</w>\nequ ities</w>\nd orian</w>\nsu ka</w>\nper l\naishwar ya</w>\npul lover</w>\npreci sion\nfair way</w>\nne ve</w>\nrive ting</w>\nvill anova</w>\nen com\nak o\npassion ately</w>\neuropale ague</w>\nsiem pre</w>\nx vi</w>\nenligh tened</w>\nc fr</w>\nâĺħâĺħ âĺħâĺħ</w>\nwast eland</w>\nis f</w>\nnew comers</w>\nemergen cy\namphi theatre</w>\n- .</w>\ntext books</w>\nfigur ative</w>\ntre mb\npe sc\nab hin\nab bot</w>\nac acia</w>\nhar ds</w>\npor sche\nkau ai</w>\nel isa</w>\ncar rick</w>\nabo u</w>\nelli er</w>\nbe ch\nneu tron</w>\ngalap agos</w>\nru ben\nin nis\nhow to</w>\nnun s</w>\nsab ine</w>\ni ac</w>\nclin ched</w>\nno tori\nfi ves</w>\ncairn gor\nper i</w>\ngr c</w>\nðŁĴ¯ ðŁĴ¯</w>\nmal m\ntwelf th</w>\ndi ff\nrout ines</w>\nmarty n</w>\nlin den\nsynthesi zer</w>\nnu mber\ngame cube</w>\nfal kirk</w>\nbyz antine</w>\nqueu ing</w>\ngr ill\nscal able</w>\nchar red</w>\nrou ting</w>\nher bali\ngri zz</w>\nðŁĺŃðŁĺŃ ðŁĺŃ\ntol l\ntermin als</w>\nl pc</w>\nab d</w>\nwar mups</w>\nremo vable</w>\nÂ¯ \\\nvi go<


n)) return;

            switch (ShapeView.Shape)
            {
                case Arc arc:
                    arc.Position = position;
                    break;
                case Diagonal diagonal:
                    diagonal.Position = position;
                    break;

            }
        }

        private void OnDirectionChanged(object sender, EventArgs e)
        {
            if (!(sender is Picker picker)) return;
            if (!Enum.TryParse<ShapeDirection>(picker.SelectedItem?.ToString(), out var direction)) return;

            switch (ShapeView.Shape)
            {
                case Diagonal diagonal:
                    diagonal.Direction = direction;
                    break;

            }
        }

        private void OnIsCropInsideToggled(object sender, ToggledEventArgs e)
        {
            if (!(ShapeView.Shape is Arc arc)) return;

            arc.IsCropInside = IsCropInsideSwitch.IsToggled;
        }

        private void OnArcHeightChanged(object sender, EventArgs e)
        {
            if (!(ShapeView.Shape is Arc arc)) return;

            arc.ArcHeight = ArcHeightSlider.Value;
        }

        private void OnDiagonalAngleChanged(object sender, EventArgs e)
        {
            if (!(ShapeView.Shape is Diagonal diagonal)) return;

            diagonal.Angle = DiagonalAngleSlider.Value;
        }

        private void OnCornerRadiusChanged(object sender, ValueChangedEventArgs e)
        {
            if (!(ShapeView.Shape is RoundRect roundRect)) return;

            roundRect.CornerRadius = new CornerRadius(TopLeftCornerSlider.Value, TopRightCornerSlider.Value,
                BottomLeftCornerSlider.Value, BottomRightCornerSlider.Value);
        }

        private void OnClipSizeChanged(object sender, ValueChangedEventArgs e)
        {
            if (!(ShapeView.Shape is CornerClip cornerClip)) return;

            cornerClip.ClipSize = new CornerRadius(TopLeftClipSizeSlider.Value, TopRightClipSizeSlider.Value,
                BottomLeftClipSizeSlider.Value, BottomRightClipSizeSlider.Value);
        }

        private void OnTrianglePointsChanged(object sender, ValueChangedEventArgs e)
        {
            if (!(ShapeView.Shape is Triangle triangle)) return;

            triangle.PointA = new Point(PointAX.Value, PointAY.Value);
            triangle.PointB = new Point(PointBX.Value, PointBY.Value);
            triangle.PointC = new Point(PointCX.Value, PointCY.Value);
        }
    }
}


message.roomId)) {
            if (this._games.get(message.roomId).won || this._games.get(message.roomId).isGameOver) {
                this._games.delete(message.roomId);
            }
        }

        commandName = commandName.trim().toLowerCase();

        if (input) input = input.trim().toLowerCase();

        // Create a new hangman game
        if (commandName === 'start') {
            if (this._games.has(message.roomId)) {
                return message.reply(`There is already an active game for this room.`);
            } else {
                let newGame: Game = new Game(message.userId);
                let started = await newGame.start();

                if (started) {
                    this._games.set(message.roomId, newGame);
                    let letters: string[] = newGame.getLettersToShow();
                    let output: string = `I'm thinking of a **${letters.length}** lettered word. Start guessing.\n`;

                    for (let i = 0; i < letters.length; i++) {
                        output += letters[i] + ' ';
                    }
                    return message.reply(output);
                }
            }
        }
        else if (commandName === 'end') {

            if (!this._games.get(message.roomId)) {
                return message.reply('There is no game in progress.');
            }

            // Only allow the user that created the game to end it
            if (this._games.get(message.roomId).ownerId !== message.userId) {
                return message.reply('You must be the owner of this game to end it.');
            }

            let output: string = this._games.get(message.roomId).gameOver(false);
            this._games.delete(message.roomId);
            return message.reply(output);
        }
        else if (commandName === 'guess') {
            if (!this._games.has(message.roomId)) {
                return message.reply(`There is no game in progress for this room.`);
            }

            if (!input) return message.reply('Please provide a guess.');

            // Destroy the game after 5 minutes
            let diff: Time = TimeUtil.difference(Date.now(), this._games.get(message.roomId).startTime);

            if (diff.seconds > 300) {
                this._games.delete(message.roomId);
                return message.reply('The game has ended. Use `start` to begin another game.')
            }

            // Only use the first character as the guess
            input = input[0];

            let response: string = this._games.get(message.roomId).guess(input);

            return message.reply(response);
        }
    }
}
export class SiteConfig {

	public static mailToURL: string = "mailto:orders@venomrox.com";
}

export enum ItemSize {
	S,
	M,
	L,
	XL,
	XXL
}

export enum ItemCategory {
	Shirts,
	Hats,
	Accessories
}

export enum ItemColor {
	Black,
	Grey,
	White,
	LightPink,
	DarkPink,
	TT_BlackPink,
	TT_BlackBlack,
	TT_BlackGrey,
	Teal,
	Purple
}

var ColorName = {
	Black: "Black",
	Grey: "Grey",
	White: "White",
	LightPink: "Light Pink",
	DarkPink: "Dark Pink",
	TT_BlackPink: "Black/Pink",
	TT_BlackBlack: "Black/Black",
	TT_BlackGrey: "Black/Grey",
	Teal: "Teal",
	Purple: "Purple"
}

interface IStoreItem {
	itemCode: string;


lt<EventLoop> {
    trace!(target: "master::event_loop", "creating poll");
    let mut poll = Poll::new().describe_err("can't create poll")?;

    trace!(target: "master::event_loop", "creating events collection");
    let events = Events::with_capacity(1024);

    trace!(target: "master::event_loop", "registering server");
    server
      .register_into(&mut poll)
      .describe_err("can't register server")?;

    Ok(EventLoop {
      poll,
      events,
      server,
    })
  }

  fn run(&mut self) -> IoResult<()> {
    loop {
      trace!(target: "master::event_loop", "tick");
      self.tick()?;
    }
  }

  fn tick(&mut self) -> IoResult<()> {
    let events_count = self
      .poll
      .poll(&mut self.events, None)
      .describe_err("can't get events")?;
    trace!(target: "master::event_loop", "events_count = {}", events_count);

    for event in self.events.iter() {
      trace!(target: "master::event_loop", "event = {:?}", event);

      if let Err(error) = self.server.handle_event(&mut self.poll, event) {
        return Err(error);
      }
    }

    Ok(())
  }
}
<reponame>KaiJewson/inline-proc<gh_stars>10-100
//! The `invoke_inline_macro!` macro.

use proc_macro::TokenStream as TokenStream1;
use proc_macro2::TokenStream;

use libloading::{Library, Symbol};
use proc_macro_error::abort;
use syn::parse::{Parse, ParseStream};
use syn::{Ident, LitStr};

pub(super) fn invoke_inline_macro(input: TokenStream1) -> TokenStream1 {
    let input: InvokerInput = syn::parse_macro_input!(input);

    let library = Library::new(input.dylib_path.value())
        .unwrap_or_else(|e| abort!(input.dylib_path, "Failed to open library: {}", e));

    match input.macro_type {
        MacroType::Bang(tokens) => {
            let macro_function: Symbol<fn(TokenStream1) -> TokenStream1> =
                unsafe { library_macro(&library, "bang", input.name) };
            macro_function(tokens.into())
        }
        MacroType::Derive(item) => {
            let macro_function: Symbol<fn(TokenStream1) -> TokenStream1> =
                unsafe { library_macro(&library, "derive", input.name) };
            macro_function(item.into())
        }
        MacroType::Attribute(attr, item) => {
            let macro_function: Symbol<fn(TokenStream1, TokenStream1) -> TokenStream1> =
                unsafe { library_macro(&library, "attribute", input.name) };
            macro_function(attr.into(), item.into())
        }
    }
}

struct InvokerInput {
    dylib_path: LitStr,
    name: Ident,
    macro_type: MacroType,
}

impl Parse for InvokerInput {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        Ok(Self {
            dylib_path: input.parse::<LitStr>()?,
            name: input.parse::<Ident>()?,
            macro_type: input.parse()?,
        })
    }
}

enum MacroType {
    Bang(TokenStream),
    Derive(TokenStream),
    Attribute(TokenStream, TokenStream),
}

impl Parse for MacroType {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let ty = input.parse::<Ident>()?;

        Ok(match &*ty.to_string() {
            "bang" => Self::Bang(input.parse()?),
            "derive" => Self::Derive


Beats0.github.io/www.mygalgame.com/wp-login.php?redirect_to=https%3A%2F%2Fwww.mygalgame.com%2F%25e5%258f%25a3%25e8%25a2%258b%25e5%25b0%2591%25e5%25a5%25b3.html">登录以回复

  毫无意义说道：

  <time datetime="2016-10-13T00:15:59+00:00"> 2016年10月13日 上午12:15 </time>

好小！但还是下着玩玩吧

登录以回复

  429456452说道：

  <time datetime="2016-10-19T23:44:12+00:00"> 2016年10月19日 下午11:44 </time>
  <div class="comment-conte


(JS::Handle<JSObject *> obj, JS::MutableHandle<JSObject *> mutableObj)
{
  // Prevent the linker from unifying this function with others that are
  // equivalent in machine code but not type.
  fprintf(stderr, "Called " __FILE__ ":callee\n");
  breakpoint();
}

FRAGMENT(Root, handle) {
  JS::Rooted<JSObject *> global(cx, JS::CurrentGlobalOrNull(cx));
  callee(global, &global);
  (void) global;
}

FRAGMENT(Root, HeapSlot) {
  JS::Rooted<jsval> plinth(cx, STRING_TO_JSVAL(JS_NewStringCopyZ(cx, "plinth")));
  JS::Rooted<JSObject *> array(cx, JS_NewArrayObject(cx, JS::HandleValueArray(plinth)));

  breakpoint();

  (void) plinth;
  (void) array;
}

FRAGMENT(Root, barriers) {
  JSObject *obj = JS_NewObject(cx, nullptr, JS::NullPtr(), JS::NullPtr());
  js::PreBarriered<JSObject *> prebarriered(obj);
  js::HeapPtr<JSObject *> heapptr(obj);
  js::RelocatablePtr<JSObject *> relocatable(obj);

  JS::Value val = JS::ObjectValue(*obj);
  js::PreBarrieredValue prebarrieredValue(JS::ObjectValue(*obj));
  js::HeapValue heapValue(JS::ObjectValue(*obj));
  js::RelocatableValue relocatableValue(JS::ObjectValue(*obj));

  breakpoint();

  (void) prebarriered;
  (void) heapptr;
  (void) relocatable;
  (void) val;
  (void) prebarrieredValue;
  (void) heapValue;
  (void) relocatableValue;
}

/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 4 -*- */
/* 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/. */

#include "VMPI.h"

// Note, this is not supported in configurations with more than one AvmCore running
// in the same process.

#ifdef WIN32
#include "windows.h"
#else
#define __cdecl
#include <stdarg.h>
#include <string.h>
#endif

#include "vprof.h"

#ifndef MIN
#define MIN(x,y) ((x) <= (y) ? x : y)
#endif
#ifndef MAX
#define MAX(x,y) ((x) >= (y) ? x : y)
#endif

#ifndef MAXINT
#define MAXINT int(unsigned(-1)>>1)
#endif

#ifndef MAXINT64
#define MAXINT64 int64_t(uint64_t(-1)>>1)
#endif

#ifndef __STDC_WANT_SECURE_LIB__
#define sprintf_s(b,size,fmt,...) sprintf((b),(fmt),__VA_ARGS__)
#endif

#if THREADED
#define DO_LOCK(lock) Lock(lock); {
#define DO_UNLOCK(lock) }; Unlock(lock)
#else
#define DO_LOCK(lock) { (void)(lock);
#define DO_UNLOCK(lock) }
#endif

#if THREAD_SAFE
#define LOCK(lock) DO_LOCK(lock)
#define UNLOCK(lock) DO_UNLOCK(lock)
#else
#define LOCK(lock) { (void)(lock);
#define UNLOCK(lock) }
#endif

static entry* entries = nullptr;
static bool notInitialized = true;
static long glock = LOCK_IS_FREE;

#define Lock(lock) while (_InterlockedCompareExchange(lock, LOCK_I


"hello".what[yes]')).toEqual(
        Fields.index(Fields.index(Fields.literal("hello"), Fields.literal("what")), Fields.variable("yes"))
    );
});

test("Parse negated index", () => {
    expect(EXPRESSION.field.tryParse("!a[b]")).toEqual(
        Fields.negate(Fields.index(Fields.variable("a"), Fields.variable("b")))
    );
    expect(EXPRESSION.field.tryParse("!a.b")).toEqual(
        Fields.negate(Fields.index(Fields.variable("a"), Fields.literal("b")))
    );
});

// <-- Functions -->

test("Parse function with no arguments", () => {
    expect(EXPRESSION.field.tryParse("hello()")).toEqual(Fields.func(Fields.variable("hello"), []));
    expect(EXPRESSION.field.tryParse("lma0()")).toEqual(Fields.func(Fields.variable("lma0"), []));
});

test("Parse function with arguments", () => {
    expect(EXPRESSION.field.tryParse("list(1, 2, 3)")).toEqual(
        Fields.func(Fields.variable("list"), [Fields.literal(1), Fields.literal(2), Fields.literal(3)])
    );
    expect(EXPRESSION.field.tryParse('object("a", 1, "b", 2)')).toEqual(
        Fields.func(Fields.variable("object"), [
            Fields.literal("a"),
            Fields.literal(1),
            Fields.literal("b"),
            Fields.literal(2),
        ])
    );
});

test("Parse function with duration", () => {
    expect(EXPRESSION.field.tryParse("today() + dur(4hr)")).toEqual(
        Fields.binaryOp(
            Fields.func(Fields.variable("today"), []),
            "+",
            Fields.literal(Duration.fromObject({ hours: 4 }))
        )
    );
});

test("Parse function with mixed dot, index, and function call", () => {
    expect(EXPRESSION.field.tryParse("list().parts[0]")).toEqual(
        Fields.index(Fields.index(Fields.func(Fields.variable("list"), []), Fields.literal("parts")), Fields.literal(0))
    );
});

// <-- Lambdas -->
describe("Lambda Expressions", () => {
    test("Parse 0-argument constant lambda", () => {
        expect(EXPRESSION.field.tryParse("() => 16")).toEqual(Fields.lambda([], Fields.literal(16)));
    });

    test("Parse 0-argument binary op lambda", () => {
        expect(EXPRESSION.field.tryParse("() => a + 2")).toEqual(
            Fields.lambda([], Fields.binaryOp(Fields.variable("a"), "+", Fields.literal(2)))
        );
    });

    test("Parse 1-argument lambda", () => {
        expect(EXPRESSION.field.tryParse("(v) => v")).toEqual(Fields.lambda(["v"], Fields.variable("v")));
    });

    test("Parse 2-argument lambda", () => {
        expect(EXPRESSION.field.tryParse("(yes, no) => yes - no")).toEqual(
            Fields.lambda(["yes", "no"], Fields.binaryOp(Fields.variable("yes"), "-", Fields.variable("no")))
        );
    });
});

// <-- Lists -->

describe("Lists", () => {
    test("[]", () => expect(EXPRESSION.field.tryParse("[]")).toEqual(Fields.list([])));
    test("[1]", () => expect(EXPRESSION.field.tryParse("[1]")).toEqual(Fields.list([Fields.literal(1)])));
    test("[1, 2]", () =>
        expect(EXPRESSION.field.tryParse("[1,2]")).toEqual(Fields.list([Fields.literal(1), Fields.literal(2)])));
    test("[


#include <stdio.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <si7021.h>
#include <string.h>

#define CHIP_TYPE_SI70xx  // comment this line for SHT2x/HTU21D

#if defined(CONFIG_IDF_TARGET_ESP8266)
#define SDA_GPIO 4
#define SCL_GPIO 5
#else
#define SDA_GPIO 16
#define SCL_GPIO 17
#endif

#if defined(CONFIG_IDF_TARGET_ESP32S2)
#define APP_CPU_NUM PRO_CPU_NUM
#endif

void task(void *pvParamters)
{
    i2c_dev_t dev;
    memset(&dev, 0, sizeof(i2c_dev_t));

    ESP_ERROR_CHECK(si7021_init_desc(&dev, 0, SDA_GPIO, SCL_GPIO));

#ifdef CHIP_TYPE_SI70xx
    uint64_t serial;
    si7021_device_id_t id;

    ESP_ERROR_CHECK(si7021_get_serial(&dev, &serial, false));
    ESP_ERROR_CHECK(si7021_get_device_id(&dev, &id));

    printf("Device: ");
    switch (id)
    {
        case SI_MODEL_SI7013:
            printf("Si7013");
            break;
        case SI_MODEL_SI7020:
            printf("Si7020");
            break;
        case SI_MODEL_SI7021:
            printf("Si7021");
            break;
        case SI_MODEL_SAMPLE:
            printf("Engineering sample");
            break;
        default:
            printf("Unknown");
    }
    printf("\nSerial number: 0x%08x%08x\n", (uint32_t)(serial >> 32), (uint32_t)serial);
#endif

    float val;
    esp_err_t res;

    while (1)
    {
        /* float is used in printf(). you need non-default configuration in
         * sdkconfig for ESP8266, which is enabled by default for this
         * example. see sdkconfig.defaults.esp8266
         */
        res = si7021_measure_temperature(&dev, &val);
        if (res != ESP_OK)
            printf("Could not measure temperature: %d (%s)\n", res, esp_err_to_name(res));
        else
            printf("Temperature: %.2f\n", val);

        res = si7021_measure_humidity(&dev, &val);
        if (res != ESP_OK)
            printf("Could not measure humidity: %d (%s)\n", res, esp_err_to_name(res));
        else
            printf("Humidity: %.2f\n", val);

        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void app_main()
{
    ESP_ERROR_CHECK(i2cdev_init());

    xTaskCreatePinnedToCore(task, "test", configMINIMAL_STACK_SIZE * 8, NULL, 5, NULL, APP_CPU_NUM);
}


             Answer("Los vecinos hablan sobre el partido los días previos, se nota el ambiente en la calle.",listOf(Point(Team.Celtic, 4), Point(Team.Farsa, 10), Point(Team.GranadaCF,1), Point(Team.RMadrid, 9))),
             Answer("No como ni duermo los días previos de los nervios. Da igual que sean dieciseisavos de Copa o la última jornada de Liga, lo vivo.",listOf(Point(Team.Celtic, 8), Point(Team.Farsa, 1), Point(Team.GranadaCF,10), Point(Team.RMadrid, 0)))
        )),
        Question(
       "Estás en un bar y te das cuenta de que nadie es del mismo equipo que tú, ¿qué piensas?",
        listOf(
               Answer("Joder, mira que es raro.", listOf(Point(Team.Celtic, 10), Point(Team.Farsa, 0), Point(Team.GranadaCF, 3), Point(Team.RMadrid, 2))),
               Answer("Ya está esto lleno de borregos, míralos, todos viendo el Chirincirco.",listOf(Point(Team.Celtic, 1), Point(Team.Farsa, 7), Point(Team.GranadaCF,4), Point(Team.RMadrid, 9))),
               Answer("Normal, si somos 4 gatos. Eh, pero con orgullo, coño.",listOf(Point(Team.Celtic, 2), Point(Team.Farsa, 10), Point(Team.GranadaCF,1), Point(Team.RMadrid, 2))),
               Answer("Ups, igual tenía que haber ido al de dos calles más abajo...",listOf(Point(Team.Celtic, 10), Point(Team.Farsa, 1), Point(Team.GranadaCF,4), Point(Team.RMadrid, 1)))
                )),
        Question(
       "Penalti a favor del Madrid/Barcelona. En la repetición se ve que no era. ¿Cómo reaccionas?",
        listOf(
                Answer("Ya están robando estos perros.", listOf(Point(Team.Celtic, 10), Point(Team.Farsa, 0), Point(Team.GranadaCF, 9), Point(Team.RMadrid, 2))),
                Answer("Esto es una puta vergüenza! Soy el entrenador y los saco del campo, que se rían de su madre.",listOf(Point(Team.Celtic, 3), Point(Team.Farsa, 10), Point(Team.GranadaCF,3), Point(Team.RMadrid, 9))),
                Answer("Ya la tenemos liada, ahora a aguantar a la prensa toda la semana...",listOf(Point(Team.Celtic, 4), Point(Team.Farsa, 0), Point(Team.GranadaCF,9), Point(Team.RMadrid, 2))),
                Answer("Ya estamos con la prensa mamadora del movimiento",listOf(Point(Team.Celtic, 10), Point(Team.Farsa, 0), Point(Team.GranadaCF,9), Point(Team.RMadrid, 2)))
                )),
        Question(
       "Caso contrario: última jornada de liga y una victoria de tu equipo hace que supere el objetivo marcado al principio del año.",
        listOf(
                Answer("Coño, coño, coño, coño, coño, coño. Como les dé por ganar me desnudo en la fuente del pueblo.", listOf(Point(Team.Celtic, 10), Point(Team.Farsa, 0), Point(Team.GranadaCF, 9), Point(Team.RMadrid, 2))),
                Answer("Yaya, enséñame unos rezos de esos, que es para una cosa del finde.",listOf(Point(Team.Celtic, 1), Point(Team.Farsa, 9), Point(Team.GranadaCF,2), Point(Team.RMadrid, 6))),


HOST_CONFIG_IP3516HS))

#define USB_HOST_CONFIG_IP3516HS_MAX_PIPE (32U)

/*!
 * @brief ohci ED max count.
 */
#define USB_HOST_CONFIG_IP3516HS_MAX_ATL (32U)

/*!
 * @brief ohci GTD max count.
 */
#define USB_HOST_CONFIG_IP3516HS_MAX_INT (32U)

/*!
 * @brief ohci ITD max count.
 */
#define USB_HOST_CONFIG_IP3516HS_MAX_ISO (0U)

#endif

/*!
 * @brief host HUB class instance count, meantime it indicates HUB class enable or disable.
 *        - if 0, host HUB class driver is disable.
 *        - if greater than 0, host HUB class driver is enable.
 */
#define USB_HOST_CONFIG_HUB (1U)

/*!
 * @brief host HID class instance count, meantime it indicates HID class enable or disable.
 *        - if 0, host HID class driver is disable.
 *        - if greater than 0, host HID class driver is enable.
 */
#define USB_HOST_CONFIG_HID (1U)

/*!
 * @brief host MSD class instance count, meantime it indicates MSD class enable or disable.
 *        - if 0, host MSD class driver is disable.
 *        - if greater than 0, host MSD class driver is enable.
 */
#define USB_HOST_CONFIG_MSD (1U)

/*!
 * @brief host CDC class instance count, meantime it indicates CDC class enable or disable.
 *        - if 0, host CDC class driver is disable.
 *        - if greater than 0, host CDC class driver is enable.
 */
#define USB_HOST_CONFIG_CDC (1U)

/*!
 * @brief host AUDIO class instance count, meantime it indicates AUDIO class enable or disable.
 *        - if 0, host AUDIO class driver is disable.
 *        - if greater than 0, host AUDIO class driver is enable.
 */
#define USB_HOST_CONFIG_AUDIO (1U)

/*!
 * @brief host PHDC class instance count, meantime it indicates PHDC class enable or disable.
 *        - if 0, host PHDC class driver is disable.
 *        - if greater than 0, host PHDC class driver is enable.
 */
#define USB_HOST_CONFIG_PHDC (1U)

/*!
 * @brief host printer class instance count, meantime it indicates printer class enable or disable.
 *        - if 0, host printer class driver is disable.
 *        - if greater than 0, host printer class driver is enable.
 */
#define USB_HOST_CONFIG_PRINTER (1U)

#endif /* _USB_HOST_CONFIG_H_ */


atformV1Feature();
  buildCounterGoogleCloudAiplatformV1Feature++;
  if (buildCounterGoogleCloudAiplatformV1Feature < 3) {
    o.createTime = 'foo';
    o.description = 'foo';
    o.disableMonitoring = true;
    o.etag = 'foo';
    o.labels = buildUnnamed135();
    o.monitoringStatsAnomalies = buildUnnamed136();
    o.name = 'foo';
    o.pointOfContact = 'foo';
    o.updateTime = 'foo';
    o.valueType = 'foo';
    o.versionColumnName = 'foo';
  }
  buildCounterGoogleCloudAiplatformV1Feature--;
  return o;
}

void checkGoogleCloudAiplatformV1Feature(api.GoogleCloudAiplatformV1Feature o) {
  buildCounterGoogleCloudAiplatformV1Feature++;
  if (buildCounterGoogleCloudAiplatformV1Feature < 3) {
    unittest.expect(o.createTime!, unittest.equals('foo'));
    unittest.expect(o.description!, unittest.equals('foo'));
    unittest.expect(o.disableMonitoring!, unittest.isTrue);
    unittest.expect(o.etag!, unittest.equals('foo'));
    checkUnnamed135(o.labels!);
    checkUnnamed136(o.monitoringStatsAnomalies!);
    unittest.expect(o.name!, unittest.equals('foo'));
    unittest.expect(o.pointOfContact!, unittest.equals('foo'));
    unittest.expect(o.updateTime!, unittest.equals('foo'));
    unittest.expect(o.valueType!, unittest.equals('foo'));
    unittest.expect(o.versionColumnName!, unittest.equals('foo'));
  }
  buildCounterGoogleCloudAiplatformV1Feature--;
}

core.Map<core.String, core.String> buildUnnamed137() => {
  'x': 'foo',
  'y': 'foo',
};

void checkUnnamed137(core.Map<core.String, core.String> o) {
  unittest.expect(o, unittest.hasLength(2));
  unittest.expect(o['x']!, unittest.equals('foo'));
  unittest.expect(o['y']!, unittest.equals('foo'));
}

core.int buildCounterGoogleCloudAiplatformV1FeatureGroup = 0;
api.GoogleCloudAiplatformV1FeatureGroup
buildGoogleCloudAiplatformV1FeatureGroup() {
  final o = api.GoogleCloudAiplatformV1FeatureGroup();
  buildCounterGoogleCloudAiplatformV1FeatureGroup++;
  if (buildCounterGoogleCloudAiplatformV1FeatureGroup < 3) {
    o.bigQuery = buildGoogleCloudAiplatformV1FeatureGroupBigQuery();
    o.createTime = 'foo';
    o.description = 'foo';
    o.etag = 'foo';
    o.labels = buildUnnamed137();
    o.name = 'foo';
    o.serviceAccountEmail = 'foo';
    o.serviceAgentType = 'foo';
    o.updateTime = 'foo';
  }
  buildCounterGoogleCloudAiplatformV1FeatureGroup--;
  return o;
}

void checkGoogleCloudAiplatformV1FeatureGroup(
  api.GoogleCloudAiplatformV1FeatureGroup o,
) {
  buildCounterGoogleCloudAiplatformV1FeatureGroup++;
  if (buildCounterGoogleCloudAiplatformV1FeatureGroup < 3) {
    checkGoogleCloudAiplatformV1FeatureGroupBigQuery(o.bigQuery!);
    unittest.expect(o.createTime!, unittest.equals('foo'));
    unittest.expect(o.description!, unittest.equals('foo'));
    unittest.expect(o.etag!, unittest.equals('foo'));
    checkUnnamed137(o.labels!);
    unittest.expect(o.name!, unittest.equals('foo'));
    unittest.expect(o.serviceAccountEmail!, unittest.equals('foo'));
    unittest.expect(o.serviceAgentType!, unittest.equals('foo'));
    unittest.expect(o.updateTime!, unittest.equals('foo'));
  }
  buildCounterGoogleCloudAiplatformV1FeatureGroup--;
}

core.List<core.String


using ICSharpCode.Decompiler.CSharp.Syntax;

namespace Hast.Synthesis.Models;

/// <summary>
/// Timing report containing hardware timing information on binary operations.
/// </summary>
public interface ITimingReport
{
    /// <summary>
    /// Retrieves the timing value for the given binary operation.
    /// </summary>
    /// <param name="binaryOperator">The operator of the binary operation.</param>
    /// <param name="operandSizeBits">The size of the operation's operands, in bits.</param>
    /// <param name="isSigned">Indicates whether the operands are signed.</param>
    /// <param name="constantOperand">
    /// If one of the operand of the operation is constant then supply the value here (due to compiler optimizations the
    /// latency can be different - smaller - in such a case).
    /// </param>
    /// <returns>The latency, in ns, what the operation will roughly take. -1


) {
		begin_visual_change ();
		Outline::set_outline_color (c);
		_props->outline_color = c;
		end_visual_change ();
	}
}

void
WaveView::set_samples_per_pixel (double samples_per_pixel)
{
	if (_props->samples_per_pixel != samples_per_pixel) {
		begin_change ();

		_props->samples_per_pixel = samples_per_pixel;
		set_bbox_dirty ();

		end_change ();
	}
}

static inline float
_log_meter (float power, double lower_db, double upper_db, double non_linearity)
{
	return (power < lower_db ? 0.0 : pow((power-lower_db)/(upper_db-lower_db), non_linearity));
}

static inline float
alt_log_meter (float power)
{
	return _log_meter (power, -192.0, 0.0, 8.0);
}

void
WaveView::set_clip_level (double dB)
{
	const double clip_level = dB_to_coefficient (dB);
	if (_global_clip_level != clip_level) {
		_global_clip_level = clip_level;
		ClipLevelChanged ();
	}
}

std::shared_ptr<WaveViewDrawRequest>
WaveView::create_draw_request (WaveViewProperties const& props) const
{
	assert (props.is_valid());

	std::shared_ptr<WaveViewDrawRequest> request (new WaveViewDrawRequest);

	request->image = std::shared_ptr<WaveViewImage> (new WaveViewImage (_region, props));
	return request;
}

void
WaveView::prepare_for_render (Rect const& area) const
{
	if (draw_image_in_gui_thread()) {
		// Drawing image in GUI thread in WaveView::render
		return;
	}

	Rect draw_rect;
	Rect self_rect;

	// all in window coordinate space
	if (!get_item_and_draw_rect_in_window_coords (area, self_rect, draw_rect)) {
		return;
	}

	double const image_start_pixel_offset = draw_rect.x0 - self_rect.x0;
	double const image_end_pixel_offset = draw_rect.x1 - self_rect.x0;

	WaveViewProperties required_props = *_props;

	required_props.set_sample_positions_from_pixel_offsets (image_start_pixel_offset,
	                                                        image_end_pixel_offset);

	if (!required_props.is_valid ()) {
		return;
	}

	if (_image) {
		if (_image->props.is_equivalent (required_props)) {
			return;
		} else {
			// Image does not contain sample area required
		}
	}

	std::shared_ptr<WaveViewDrawRequest> request = create_draw_request (required_props);

	queue_draw_request (request);
}

bool
WaveView::get_item_and_draw_rect_in_window_coords (Rect const& canvas_rect, Rect& item_rect,
                                                   Rect& draw_rect) const
{
	/* a WaveView is intimately connected to an AudioRegion. It will
	 * display the waveform within the region, anywhere from the start of
	 * the region to its end.
	 *
	 * the area we've been asked to render may overlap with area covered
	 * by the region in any of the normal ways:
	 *
	 *  - it may begin and end within the area covered by the region
	 *  - it may start before and end after the area covered by region
	 *  - it may start before and end within the area covered by the region
	 *  - it may start within and end after the area covered by the region
	 *  - it may be precisely coincident with the area covered by region.
	 *
	 * So let's start by determining the area covered by the region, in
	 * window coordinates. It begins at zero (in item coordinates for this
	 * waveview, and extends to region_length() / _sampl


.pw-container>.ui-helper-clearfix>form{position:relative;top:-1px}#head_button{float:right;margin:0;position:relative;top:-0.35em}#head_button button{font-size:1.3em;margin-right:0;margin-left:10px;margin-top:0;float:right;border:none}#head_button button.pw-button-dropdown-toggle{margin-left:0}ul.action-group li{float:left;margin:0}ul.action-group li a{display:block;border:1px solid #d4e0e4;padding:.3em 1em;border-radius:3px;font-size:.875em;color:#2f4248 !important}ul.action-group li a:hover{border-color:#b4cad1;text-decoration:none !important;color:#2f4248 !important}ul.action-group li a i.fa{color:#777 !important}#action_icons span{border-radius:3px;color:#fff !important;background:#7ea0ab !important}#action_icons span:hover{color:#fff !important;background:#93bf0d !important}.pw-content img{display:block}.pw-content .nav a.label{font-size:1em}.pw-content p,.pw-content ul ol,.pw-content table{margin:1em 0}.pw-content table th,.pw-content table th.header,.pw-content table.AdminDataList th,.pw-content h4{color:#6c96a4}.pw-content table.AdminDataList th{font-size:.8em}.pw-content .pw-container>table.AdminDataList{margin-top:1em}.pw-content h2{margin:0 0 .5em 0;font-size:1.2em;line-height:1.2em}.pw-content h2 a{text-decoration:underline}.pw-content h2 a:hover{color:#fff;background:#940b4e;text-decoration:none}.pw-content h3{margin:1em 0;font-size:1.2em}.pw-content h4{margin:1em 0 .25em 0;font-weight:700;font-size:.9166666667em}.pw-content li{margin:1em 0;display:block;list-style:disc}.pw-content ol li{display:list-item;list-style-type:decimal;margin-left:1em}.pw-content .PageList a{padding:0 4px 0 4px;border-radius:3px}.pw-content .PageListActions{margin-left:-2px}.pw-content .PageListStatusIcon{color:#8eacb5}.pw-content ul.actions li,.pw-content .PageListActions li,.pw-content li.action{border:none;padding:0 1px;margin:0;margin-right:3px}.pw-content ul.actions li:first-child:before,.pw-content .PageListActions li:first-child:before,.pw-content li.action:first-child:before{content:"›";margin-right:3px;color:#adc2c9}.pw-content li.action a,.pw-content .actions a,.pw-content .PageList .actions a,.pw-content .PageListMoveNote a{padding:0 4px 0 4px;display:inline-block;font-size:.9230769231em;border-radius:3px;border:none !important;font-weight:normal;color:#6c96a4;background:""}.pw-content .actions a:hover,.pw-content li.action a:hover,.pw-content .PageListMoveNote a:hover{color:#fff !important;background:#db1174;border:none}.pw-content .PageListMoveNote{text-transform:lowercase;cursor:move}.pw-content .PageListItem>a span{display:inline-block}.pw-content .PageListItem>a span+span:before{content:" / ";color:#777}.pw-content .PageListActionMore a{margin-top:.5em


mand } from './toc-builder-command'
import { TocEntry } from './toc-entry'
import { TocEntryService } from './toc-entry-service'

describe('TocBuilder', () => {
  let tocBuilder: TraitTocBuilder
  let foo: HTMLElement
  let bar: HTMLElement
  let baz: HTMLElement

  beforeEach(() => {
    document.body.appendChild(
      document.createRange().createContextualFragment(`

foo

bar

baz

      `)
    )

    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
    foo = document.getElementById('foo')!
    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
    bar = document.getElementById('bar')!
    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
    baz = document.getElementById('baz')!

    tocBuilder = new TocBuilder(
      new TocEntryDomAdaptor(),
      new TocListItemAdaptor(),
      new TocEntryService(new TocEntryDomAdaptor(), new TocListItemAdaptor())
    )

    tocBuilder.build([
      new TocBuilderCommand(new Selector('h1', 1), [foo]),
      new TocBuilderCommand(new Selector('h2', 2), [bar]),
      new TocBuilderCommand(new Selector('h1', 1), [baz])
    ])
  })

  afterEach(() => {
    document.body.innerHTML = ''
  })

  test('get', () => {
    const lists = tocBuilder.get().getItems()
    expect(lists).toHaveLength(2)
    expect(lists).toMatchObject([expect.any(TocEntry), expect.any(TocEntry)])

    const childLists = lists[0].getItems()
    expect(childLists).toHaveLength(1)
    expect(childLists).toMatchObject([expect.any(TocEntry)])

    expect(lists[1].getItems()).toHaveLength(0)
  })

  test('getList', () => {
    expect(tocBuilder.getList()).toHaveLength(3)
  })
})
export class Input {
  id: String;
  name: String;
  unit: String;
  quantity: String;
  input_price: String;
  retail_price: String;
  total: String;
  note: String;
  properties: String;

  constructor(  id: String,name: String,unit:String, quantity: String,input_price: String,retail_price: String,total: String,note: String,properties: String) {
    this.id = id;
    this.name = name;
    this.unit = unit;
    this.quantity = quantity;
    this.input_price = input_price;
    this.retail_price = retail_price;
    this.total = total;
    this.note = note;
    this.properties = properties;
  }
}import lambdaTester from 'lambda-tester'
import { expect } from 'chai'
import { findOne, find, create, update, deleteOne } from '../src/handler'
import * as booksMock from './books.mock'
import { books as BooksModel } from '../src/model/books'
import sinon from 'sinon'

describe('FindOne [GET]', () => {
  it('success', () => {
    try {
      const s = sinon.mock(BooksModel)

      s.expects('findOne').atLeast(1).atMost(3).resolves(booksMock.findOne)

      return lambdaTester(findOne)
        .event({ pathParameters: { id: 25768396 } })
        .expectResult((result: any) => {
          expect(result.statusCode).to.equal(200)
          const body = JSON.parse(result.body)
          expect(body.code).to.equal(0)
          s.verify()
          s.restore()
        })
    } catch


c\x92", 	// U+F0312
		"KeyboardTabReverse":	"\xf3\xb0\x8c\xa5", 	// U+F0325
		"KeyboardVariant":	"\xf3\xb0\x8c\x93", 	// U+F0313
		"Khanda":	"\xf3\xb1\x83\xbd", 	// U+F10FD
		"Kickstarter":	"\xf3\xb0\x9d\x85", 	// U+F0745
		"Kite":	"\xf3\xb1\xa6\x85", 	// U+F1985
		"KiteOutline":	"\xf3\xb1\xa6\x86", 	// U+F1986
		"Kitesurfing":	"\xf3\xb1\x9d\x84", 	// U+F1744
		"Klingon":	"\xf3\xb1\x8d\x9b", 	// U+F135B
		"Knife":	"\xf3\xb0\xa7\xbb", 	// U+F09FB
		"KnifeMilitary":	"\xf3\xb0\xa7\xbc", 	// U+F09FC
		"Knob":	"\xf3\xb1\xae\x96", 	// U+F1B96
		"Koala":	"\xf3\xb1\x9c\xbf", 	// U+F173F
		"Kodi":	"\xf3\xb0\x8c\x94", 	// U+F0314
		"Kubernetes":	"\xf3\xb1\x83\xbe", 	// U+F10FE
		"Label":	"\xf3\xb0\x8c\x95", 	// U+F0315
		"LabelMultiple":	"\xf3\xb1\x8d\xb5", 	// U+F1375
		"LabelMultipleOutline":	"\xf3\xb1\x8d\xb6", 	// U+F1376
		"LabelOff":	"\xf3\xb0\xab\x8b", 	// U+F0ACB
		"LabelOffOutline":	"\xf3\xb0\xab\x8c", 	// U+F0ACC
		"LabelOutline":	"\xf3\xb0\x8c\x96", 	// U+F0316
		"LabelPercent":	"\xf3\xb1\x8b\xaa", 	// U+F12EA
		"LabelPercentOutline":	"\xf3\xb1\x8b\xab", 	// U+F12EB
		"LabelVariant":	"\xf3\xb0\xab\x8d", 	// U+F0ACD
		"LabelVariantOutline":	"\xf3\xb0\xab\x8e", 	// U+F0ACE
		"Ladder":	"\xf3\xb1\x96\xa2", 	// U+F15A2
		"Ladybug":	"\xf3\xb0\xa0\xad", 	// U+F082D
		"Lambda":	"\xf3\xb0\x98\xa7", 	// U+F0627
		"Lamp":	"\xf3\xb0\x9a\xb5", 	// U+F06B5
		"LampOutline":	"\xf3\xb1\x9f\x90", 	// U+F17D0
		"Lamps":	"\xf3\xb1\x95\xb6", 	// U+F1576
		"LampsOutline":	"\xf3\xb1\x9f\x91", 	// U+F17D1
		"Lan":	"\xf3\xb0\x8c\x97", 	// U+F0317
		"LanCheck":	"\xf3\xb1\x8a\xaa", 	// U+F12AA
		"LanConnect":	"\xf3\xb0\x8c\x98", 	// U+F0318
		"L


mov	f72  = f0
	}
	;;
	{ .mmf
	STFD	[C2 ] = f22, 5 * SIZE
	STFD	[C10] = f23, 5 * SIZE
	mov	f73  = f0
	}
	;;
	.align 32

.L110:
	{ .mib
	nop	__LINE__
	tbit.z	p6, p7 = M, 1
	(p6)	br.cond.dptk .L120
	}
	;;
	{ .mmi
	LDFPD	f48, f49 = [B]
	adds	BOFFSET = 2 * SIZE, B
	adds	L =  1, K
	}
	;;
	{ .mii
	adds	PREA = (PREFETCHSIZE + 0) * SIZE, AOFFSET
	tbit.z	p12, p0 = L, 0
	shr	L = L, 1
	}
	;;
	{ .mmi
	LDFPD	f32, f33 = [AOFFSET], 2 * SIZE
	nop	__LINE__
	adds	L =  -1, L
	}
	;;
	{ .mmi
	cmp.eq	p3, p0 = r0, r0
	adds	PREB = (PREFETCHSIZE + 0) * SIZE, BOFFSET
	mov	ar.lc = L
	}
	;;
	.align 32

.L112:
	{ .mfi
	lfetch.nt1	[PREA],  4 * SIZE
	FMA	f64   = f32, f48, f64	// A1 * B1
	cmp.ne	p4, p5 =  0, L
	}
	{ .mfi
	lfetch.nt1	[PREB],   4 * SIZE
	FMA	f72   = f32, f49, f72	// A1 * B2
	(p12) cmp.ne p3, p0 =  0, L
	}
	;;
	{ .mmf
	(p3) LDFPD	f40, f41 = [AOFFSET], 2 * SIZE
	(p3) LDFPD	f56, f57 = [BOFFSET], 2 * SIZE
	FMA	f65   = f33, f48, f65	// A2 * B1
	}
	{ .mmf
	(p5) LDFD	f6 = [C1 ], SIZE
	(p5) LDFD	f7 = [C2 ], SIZE
	FMA	f73   = f33, f49, f73	// A2 * B2
	}
	;;
	{ .mfb
	(p4) LDFPD	f32, f33 = [AOFFSET],   2 * SIZE
	(p3) FMA	f64   = f40, f56, f64	// A1 * B1
	nop	__LINE__
	}
	{ .mfb
	(p5) LDFD	f10 = [C1 ], SIZE
	(p3) FMA	f72   = f40, f57, f72	// A1 * B2
	nop	__LINE__
	}
	;;
	{ .mfi
	(p4) LDFPD	f48, f49 = [BOFFSET],   2 * SIZE
	(p3) FMA	f65   = f41, f56, f65	// A2 * B1
	adds	L = -1, L
	}
	{ .mfb
	(p5) LDFD	f11 = [C2 ],  SIZE
	(p3) FMA	f73   = f41, f57, f73	// A2 * B2
	br.cloop.sptk.few .L112
	}
	;;
	{ .mmf
	LDFD	f12 = [C1], SIZE
	LDFD	f13 = [C2], SIZE
	FMA	f6   = ALPHA_R, f64, f6
	}
	{ .mmf
	nop	__LINE__
	nop	__LINE__


lti_thread;
mod reactor;
pub mod schedulers;
pub mod single_thread;

use futures_lite::{AsyncRead, AsyncWrite, Stream};
use futures_task::Context;
use mio::{unix::SourceFd, Interest, Token};
use std::{
    io::{self, prelude::*},
    net::{Shutdown, TcpListener, TcpStream, ToSocketAddrs},
    os::unix::prelude::*,
    pin::Pin,
    task::Poll,
};

pub struct AsyncTcpListener {
    listener: TcpListener,
    token: Token,
}

pub struct AsyncIncoming<'a> {
    inner: &'a mut AsyncTcpListener,
}

pub struct AsyncTcpStream {
    stream: TcpStream,
    token: Token,
}

impl AsyncTcpListener {
    pub fn new<A: ToSocketAddrs>(addr: A) -> io::Result<Self> {
        let listener = TcpListener::bind(addr)?;
        listener.set_nonblocking(true)?;
        let fd = listener.as_raw_fd();
        let token = Token(fd as usize);
        Ok(Self { listener, token })
    }
    pub fn incoming(&mut self) -> AsyncIncoming<'_> {
        AsyncIncoming { inner: self }
    }
}

impl Drop for AsyncTcpListener {
    fn drop(&mut self) {
        let fd = self.listener.as_raw_fd();
        reactor::deregister(&mut SourceFd(&fd), self.token).expect("Failed to deregister listener");
    }
}

impl<'a> Stream for AsyncIncoming<'a> {
    type Item = io::Result<AsyncTcpStream>;
    // type Item = AsyncTcpStream;
    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        let me = self.get_mut();
        match me.inner.listener.accept() {
            Ok((stream, _addr)) => Poll::Ready(Some(Ok(AsyncTcpStream::new(stream)))),
            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
                // register event
                let waker = cx.waker().clone();
                reactor::register(
                    &mut SourceFd(&me.inner.listener.as_raw_fd()),
                    me.inner.token,
                    Interest::READABLE,
                )
                .expect("Failed to register listener");
                reactor::add_waker(me.inner.token, Interest::READABLE, waker)
                    .expect("failed to add waker");
                Poll::Pending
            }
            Err(e) => {
                eprintln!("accept error: {}", e.to_string());
                Poll::Ready(None)
            }
        }
    }
}

impl AsyncTcpStream {
    fn new(stream: TcpStream) -> Self {
        stream
            .set_nonblocking(true)
            .expect("failed to set nonblocking");
        let token = Token(stream.as_raw_fd() as usize);
        Self { stream, token }
    }
}

impl AsyncRead for AsyncTcpStream {
    fn poll_read(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        buf: &mut [u8],
    ) -> Poll<io::Result<usize>> {
        let me = self.get_mut();
        match me.stream.read(buf) {
            Ok(i) => Poll::Ready(


 dans l'éditeur cible.",
    ),
    ExportNotificationDataOverLengthLimitIgnored(
        en = "Data exceeding length limit ignored. Please check if your output includes all your intended data.",
        ja =
            "一部のデータが長さ制限を超えているため、すべてのデータを出力することができませんでした。意図したデータが出力結果にすべて" +
                "入っているかどうかを確認してください。",
        zhCN = "部分数据超过了长度限制而被忽略，请检查生成的文件是否完整包含您所需要的数据。",
        ru =
            "Данные, превышающие предельную длину, игнорируются. Пожалуйста, проверьте," +
                " включает ли ваш вывод все предполагаемые данные.",
        fr =
            "Les données dépassant la limite de longueur sont ignorées." +
                " Veuillez vérifier que votre exportation inclut toutes les données prévues.",
    ),
    SlightRestsFilling(
        en = "Fill short rests",
        ja = "短い休符を埋める",
        zhCN = "填充短休止符",
        ru = "Заполнить короткие промежутки",
        fr = "Remplir les courtes périodes de silence",
    ),
    SlightRestsFillingDescription(
        en = "Extend note to fill the short rest between it and its next note",
        ja = "ノート同士の間に短い休符が挟まっている場合、前のノートを伸ばして隙間を埋めます",
        zhCN = "当音符之间存在较短的休止符时，将前一个音符延长来填充休止符",
        ru = "Расширить ноту, чтобы заполнить короткий промежуток между ней и следующей нотой",
        fr = "Prolonger la note pour combler le court silence qui la sépare de la note suivante.",
    ),
    SlightRestsFillingThresholdLabel(
        en = "Max length to be processed (exclusive)",
        ja = "長さが入力値未満の場合処理",
        zhCN = "适用该处理的最大长度（不含）",
        ru = "Максимальная длина, подлежащая обработке (исключительная)",
        fr = "Longueur maximale à traiter (exclusive)",
    ),
    SlightRestsFillingThresholdItem(
        en = "1/{{denominator}} note",
        ja = "{{denominator}}分音符",
        zhCN = "{{denominator}}分音符",
        ru = "1/{{denominator}} ноты",
        fr = "1/{{denominator}} note",
    ),
    UseSimpleImport(
        en = "Simple Import",
        ja = "シンプルインポート",
        zhCN = "简单导入",
        ru = "Простой импорт",
        fr = "Importation simple",
    ),
    UseSimpleImportDescription(
        en = "Ignore detail parameters to accelerate importing",
        ja = "パラメータをインポートしないことで、より早くインポートする",
        zhCN = "忽略参数，使导入更快",
        ru = "Игнорировать подробные параметры для ускорения импорта",
        fr = "Ignorer les paramètres détaillés pour accélérer l'importation",
    ),
    UseMultipleMode(
        en = "Batch conversion",
        j


ent_loop.channel(), Arc::downgrade(&handlers)),
				work_ready.clone(),
				work_ready_mutex.clone(),
			)
		).collect();

		let mut io = IoManager {
			timers: Arc::new(RwLock::new(HashMap::new())),
			handlers: handlers,
			worker_channel: worker,
			workers: workers,
			work_ready: work_ready,
		};
		event_loop.run(&mut io)?;
		Ok(())
	}
}

impl<Message> Handler for IoManager<Message> where Message: Send + Sync + 'static {
	type Timeout = Token;
	type Message = IoMessage<Message>;

	fn ready(&mut self, _event_loop: &mut EventLoop<Self>, token: Token, events: Ready) {
		let handler_index  = token.0 / TOKENS_PER_HANDLER;
		let token_id  = token.0 % TOKENS_PER_HANDLER;
		if let Some(handler) = self.handlers.read().get(handler_index) {
			if events.is_hup() {
				self.worker_channel.push(Work { work_type: WorkType::Hup, token: token_id, handler: handler.clone(), handler_id: handler_index });
			}
			else {
				if events.is_readable() {
					self.worker_channel.push(Work { work_type: WorkType::Readable, token: token_id, handler: handler.clone(), handler_id: handler_index });
				}
				if events.is_writable() {
					self.worker_channel.push(Work { work_type: WorkType::Writable, token: token_id, handler: handler.clone(), handler_id: handler_index });
				}
			}
			self.work_ready.notify_all();
		}
	}

	fn notify(&mut self, event_loop: &mut EventLoop<Self>, msg: Self::Message) {
		match msg {
			IoMessage::Shutdown => {
				self.workers.clear();
				event_loop.shutdown();
			},
			IoMessage::AddHandler { handler } => {
				let handler_id = self.handlers.write().insert(handler.clone());
				assert!(handler_id <= MAX_HANDLERS, "Too many handlers registered");
				handler.initialize(&IoContext::new(IoChannel::new(event_loop.channel(), Arc::downgrade(&self.handlers)), handler_id));
			},
			IoMessage::RemoveHandler { handler_id } => {
				// TODO: flush event loop
				self.handlers.write().remove(handler_id);
				// unregister timers
				let mut timers = self.timers.write();
				let to_remove: Vec<_> = timers.keys().cloned().filter(|timer_id| timer_id / TOKENS_PER_HANDLER == handler_id).collect();
				for timer_id in to_remove {
					let timer = timers.remove(&timer_id).expect("to_remove only contains keys from timers; qed");
					event_loop.clear_timeout(&timer.timeout);
				}
			},
			IoMessage::AddTimer { handler_id, token, delay, once } => {
				let timer_id = token + handler_id * TOKENS_PER_HANDLER;
				let timeout = event_loop.timeout(Token(timer_id), delay).expect("Error registering user timer");
				self.timers.write().insert(timer_id, UserTimer { delay: delay, timeout: timeout, once: once });
			},
			IoMessage::RemoveTimer { handler_id, token } => {
				let timer_id = token + handler_id * TOKENS_PER_HANDLER;
				if let Some(timer) = self.timers.write().remove(&timer_id) {
					event_loop.clear_timeout(&timer.timeout);
				}
			},
			IoMessage::RegisterStream { handler_id, token } => {
				if let Some(handler) = self.handlers.read().get


76] = "暗影拱顶裁决令",
[41777] = "图鉴：蚀刻帝黄晶",
[41778] = "图鉴：坚毅帝黄晶",
[41779] = "图鉴：坚韧帝黄晶",
[41780] = "图鉴：勇士的帝黄晶",
[41781] = "图鉴：迷雾森林翡翠",
[41782] = "图鉴：辉煌森林翡翠",
[41783] = "图鉴：纯净曙光猫眼石",
[41784] = "图鉴：统御曙光猫眼石",
[41785] = "图鉴：纤细曙光猫眼石",
[41786] = "图鉴：毁灭之天焰钻石",
[41787] = "图鉴：雷鸣之天焰钻石",
[41788] = "图鉴：明亮之大地侵攻钻石",
[41789] = "图鉴：铭文帝黄晶",
[41790] = "图鉴：精准血玉石",
[41791] = "图鉴：厚重秋色石",
[41792] = "图鉴：轻巧帝黄晶",
[41793] = "图鉴：凶猛帝黄晶",
[41794] = "图鉴：致命帝黄晶",
[41795] = "图鉴：永恒森林翡翠",
[41796] = "图鉴：充能曙光猫眼石",
[41797] = "图鉴：质朴之大地侵攻钻石",
[41798] = "图鉴：鼓舞之大地侵攻钻石",
[41799] = "图鉴：永恒之大地侵攻钻石",
[41800] = "深海巨腹鱼",
[41801] = "月光墨鱼",
[41802] = "帝王鳐",
[41803] = "石鳞鲶鱼",
[41805] = "北风水母",
[41806] = "蚌背鱼",
[41807] = "龙鳞天使鱼",
[41808] = "骨鳞钳鱼",
[41809] = "冰河鲑鱼",
[41810] = "利齿青鱼",
[41812] = "圆头虾虎鱼",
[41813] = "水母",
[41814] = "晶鳞鱼",
[41815] = "高级冰刺长矛",
[41816] = "怒火平息战斧",
[41817] = "图鉴：断裂血玉石",
[41818] = "图鉴：精确帝黄晶",
[41819] = "图鉴：辐光森林翡翠",
[41820] = "图鉴：防御者的曙光猫眼石",
[41821] = "寒冷长棍",


em, ex, pt lub pc).',unavailable:'%1, niedostępne'},contextmenu:{options:'Opcje menu kontekstowego'},specialChar:{toolbar:'Wstaw znak specjalny',title:'Wybierz znak specjalny',options:'Opcje znaków specjalnych'},link:{toolbar:'Wstaw/edytuj odnośnik',other:'<inny>',menu:'Edytuj odnośnik',title:'Odnośnik',info:'Informacje ',target:'Obiekt docelowy',upload:'Wyślij',advanced:'Zaawansowane',type:'Typ odnośnika',toUrl:'Adres URL',toAnchor:'Odnośnik wewnątrz strony (kotwica)',toEmail:'Adres e-mail',targetFrame:'<ramka>',targetPopup:'<wyskakujące okno>',targetFrameName:'Nazwa ramki docelowej',targetPopupName:'Nazwa wyskakującego okna',popupFeatures:'Właściwości wyskakującego okna',popupResizable:'Skalowalny',popupStatusBar:'Pasek statusu',popupLocationBar:'Pasek adresu',popupToolbar:'Pasek narzędzi',popupMenuBar:'Pasek menu',popupFullScreen:'Pełny ekran (IE)',popupScrollBars:'Paski przewijania',popupDependent:'Okno zależne (Netscape)',popupLeft:'Pozycja w poziomie',popupTop:'Pozycja w pionie',id:'Id',langDir:'Kierunek tekstu',langDirLTR:'Od lewej do prawej (LTR)',langDirRTL:'Od prawej do lewej (RTL)',acccessKey:'Klawisz dostępu',name:'Nazwa',langCode:'Kod języka',tabIndex:'Indeks kolejności',advisoryTitle:'Opis obiektu docelowego',advisoryContentType:'Typ MIME obiektu docelowego',cssClasses:'Nazwa klasy CSS',charset:'Kodowanie znaków obiektu docelowego',styles:'Styl',rel:'Relacja',selectAnchor:'Wybierz kotwicę',anchorName:'Wg nazwy',anchorId:'Wg identyfikatora',emailAddress:'Adres e-mail',emailSubject:'Temat',emailBody:'Treść',noAnchors:'(W dokumencie nie zdefiniowano żadnych kotwic)',noUrl:'Podaj adres URL',noEmail:'Podaj adres e-mail'},anchor:{toolbar:'Wstaw/edytuj kotwicę',menu:'Właściwości kotwicy',title:'Właściwości kotwicy',name:'Nazwa kotwicy',errorName:'Wpisz nazwę kotwicy',remove:'Usuń kotwicę'},list:{numberedTitle:'Właściwości list numerowanych',bulletedTitle:'Właściwości list wypunktowanych',type:'Typ punktora',start:'Początek',validateStartNumber:'Listę musi rozpoczynać liczba całkowita.',circle:'Koło',disc:'Okrąg',square:'Kwadrat',none:'Brak',notset:'<nie ustawiono>',armenian:'Numerowanie armeńskie',georgian:'Numerowanie gruzińskie (an, ban, gan itd.)',lowerRoman:'Małe cyfry rzymskie (i, ii, iii, iv, v itd.)',upperRoman:'Duże cyfry rzymskie (I, II, III, IV, V itd.)',lowerAlpha:'Małe litery (a, b, c, d, e itd.)',upperAlpha:'Duże litery (A, B, C, D, E itd.)',lowerGreek:'Małe litery greckie (alpha, beta, gamma itd.)',decimal:'Liczby (1, 2, 3 itd.)


sibleRect().height - fontChooser.getHeight()) / 2 + this.getVisibleRect().y));

		// set fields
		// START KGU#494 2018-09-10: Issue #508
		fontChooser.setFixPadding(Element.E_PADDING_FIX);
		// END KGU#494 2018-09-10
		fontChooser.setFont(Element.getFont());
		fontChooser.setVisible(true);

		// START KGU#393 2017-05-09: Issue #400 - make sure the changes were committed
		if (fontChooser.OK) {
		// END KGU#393 2017-05-09
			// get fields
			// START KGU#494 2018-09-10: Issue #508
			Element.E_PADDING_FIX = fontChooser.getFixPadding();
			// END KGU#494 2018-09-10
			Element.setFont(fontChooser.getCurrentFont());

			// save fields to ini-file
			Element.saveToINI();

			// START KGU#136 2016-03-02: Bugfix #97 - cached bounds must be invalidated
			this.resetDrawingInfo();
			// END KGU#136 2016-03-02

			// redraw diagram
			redraw();
			// START KGU#444/KGU#618 2018-12-18: Issue #417, #649
			this.adaptScrollUnits();	// May be too early to get new draw rectangle but try at least
			// END KGU#444/KGU#618 2018-12-18
		// START KGU#393 2017-05-09: Issue #400
		}
		// END KGU#393 2017-05-09

	}

	/**
	 * Enlarges the diagram font by two points
	 */
	public void fontUpNSD() {
		// change font size
		Element.setFont(new Font(Element.getFont().getFamily(), Font.PLAIN, Element.getFont().getSize() + 2));

		// save size
		Element.saveToINI();

		// START KGU#136 2016-03-02: Bugfix #97 - cached bounds must be invalidated
		this.resetDrawingInfo();
		// END KGU#136 2016-03-02

		// redraw diagram
		redraw();
		// START KGU#444/KGU#618 2018-12-18: Issue #417, #649
		this.adaptScrollUnits();	// May be too early to get new draw rectangle but try at least
		// END KGU#444/KGU#618 2018-12-18
	}

	/**
	 * Diminishes the diagram font by two points.
	 */
	public void fontDownNSD() {
		if (Element.getFont().getSize() - 2 >= 4) {
			// change font size
			Element.setFont(new Font(Element.getFont().getFamily(), Font.PLAIN, Element.getFont().getSize() - 2));

			// save size
			Element.saveToINI();

			// START KGU#136 2016-03-02: Bugfix #97 - cached bounds must be invalidated
			this.resetDrawingInfo();
			// END KGU#136 2016-03-02

			// redraw diagram
			redraw();
		}
		// START KGU#444/KGU#618 2018-12-18: Issue #417, #649
		this.adaptScrollUnits();	// May be too early to get new draw rectangle but try at least
		// END KGU#444/KGU#618 2018-12-18
	}

	/*========================================
	 * DIN conformity
	 *========================================*/
	/**
	 * Flips the graphical representation of FOR loops between DIN 66261 and
	 * ENDLESS design
	 *
	 * @see #setDIN()
	 * @see #getDIN()
	 */
	public void toggleDIN() {
		Element.E_DIN = !(Element.E_DIN);
		NSDControl.doButtons();
		// START KGU#136 2016-03-02: Bugfix #97 - cached bounds must be invalidated
		this.resetDrawingInfo();
		// END KGU#136 2016-03-02
		redraw();
	}

	/**
	 * Switches the graphical


 number, times: number)  => {
  return (createArray(times)).map(i => {
    if (Math.random() < ratio) {
      return f(i)
    } else {
      return null
    }
  })
}

export const createRanges = (values: number[])  => {
  return values.map(createRange)
}

export const createWord = (num: number)  => {
  let w = ''
  for (let i = 0; i < num; i++)
    w += alphabet[Math.floor(alphabet.length * Math.random())]
  return w
}

export const createRandomWord = (min: number, max: number)  => {
  const length = min + Math.round((max - min) * Math.random())
  return createWord(length)
}

export const createWords = (num: number, min: number, max: number)  => {
  return (createArray(num)).map(_ => createRandomWord(min, max)).join(' ')
}

export const createWordsBetween = (minWords: number, maxWords: number, minLength: number, maxLentgh: number)  => {
  const num = randomInt(minWords, maxWords)
  return (createArray(num)).map(_ => createRandomWord(minLength, maxLentgh)).join(' ')
}

export const createDeep = ()  => {
  return {
    id: createWord(8),
    name: createRandomWord(4, 12),
    address: {
      line1: createWords(3, 4, 6),
      line2: createWords(2, 4, 6)
    },
    paragraph: createWords(30, 1, 8)
  }
}

export const createAttributes = () => {
  return {
    id: randomValueOrNull(0.4, createRandomWord(2, 8)),
    className: randomValueOrNull(0.4, createWordsBetween(1, 4, 2, 8)),
    title: randomValueOrNull(0.4, createWordsBetween(1, 6, 2, 8))
  }
}

const hexAlphabet = '0123456789ABCDEF'
export const randomColor = () => {
  function randomHex() {
    const pos = Math.floor(Math.random() * hexAlphabet.length)
    return hexAlphabet[pos]
  }
  return `#${randomHex()}${randomHex()}${randomHex()}${randomHex()}${randomHex()}${randomHex()}`
}

export const createManyAttributes = repeatf(createAttributes)

export const randomInt = (min: number, max: number) => {
  return Math.floor(Math.random() * (max - min)) + min
}

export const randomOrNull = <T>(ratio: number, f: () => T): T | null => {
  if (Math.random() <= ratio)
    return f()
  else
    return null
}

export const randomValueOrNull = <T>(ratio: number, v: T): T | null => {
  if (Math.random() <= ratio)
    return v
  else
    return null
}

export const createStyles = () => {
  return {
    backgroundColor: randomOrNull(0.4, randomColor),
    color: randomOrNull(0.4, randomColor),
    border: randomOrNull(0.4, () => `${randomInt(1, 4)}px solid ${randomColor()}`)
  }
}

export const randomBoolean = () => {
  if (Math.random() <= 0.5)
    return true
  else
    return false
}

export const createManyStyles = repeatf(createStyles)

export const createProperties = () => {
  return {
    value: randomValueOrNull(0.4, createWordsBetween(1, 6, 2, 8)),
    disabled: randomOrNull(0.4, randomBoolean)
  }
}

export const createManyProperties = repeatf(createProperties)
import { HotelChainType } from "./hotel-chain-type";

export interface Pl


using System;

namespace Ardalis.SmartEnum.Core
{
    /// <summary>
    ///
    /// </summary>
    /// <typeparam name="TEnum"></typeparam>
    /// <typeparam name="TValue"></typeparam>
    public readonly struct SmartEnumThen<TEnum, TValue>
        where TEnum : ISmartEnum
        where TValue : IEquatable<TValue>, IComparable<TValue>
    {
        private readonly bool isMatch;
        private readonly ISmartEnum smartEnum;
        private readonly bool stopEvaluating;

        internal SmartEnumThen(bool isMatch, bool stopEvaluating, ISmartEnum smartEnum)
        {
            this.isMatch = isMatch;