:
	case OpCode_vstemhm:
	case OpCode_hstem:
	case OpCode_vstem:
	  has_hint = true;
	  values[pos].set_hinting ();
	  if (str.at_end (pos))
	    drop.ends_in_hint = true;
	  break;

	case OpCode_dotsection:
	  values[pos].set_hinting ();
	  break;

	default:
	  /* NONE */
	  break;
      }
      if (has_hint)
      {
	for (int i = pos - 1; i >= 0; i--)
	{
	  parsed_cs_op_t  &csop = values[(unsigned)i];
	  if (csop.is_hinting ())
	    break;
	  csop.set_hinting ();
	  if (csop.op == OpCode_vsindexcs)
	    drop.vsindex_dropped = true;
	}
	seen_hint |= has_hint;
      }
    }

    /* Raise all_dropped flag if all operators except return are dropped from a subr.
     * It may happen even after seeing the first moveto if a subr contains
     * only (usually one) hintmask operator, then calls to this subr can be dropped.
     */
    drop.all_dropped = true;
    for (unsigned int pos = 0; pos < count; pos++)
    {
      parsed_cs_op_t  &csop = values[pos];
      if (csop.op == OpCode_return)
	break;
      if (!csop.is_hinting ())
      {
	drop.all_dropped = false;
	break;
      }
    }

    return seen_hint;
  }

  bool closure_subroutines (const parsed_cs_str_vec_t& global_subrs,
                            const hb_vector_t<parsed_cs_str_vec_t>& local_subrs)
  {
    closures.reset ();
    for (auto _ : plan->new_to_old_gid_list)
    {
      hb_codepoint_t new_glyph = _.first;
      hb_codepoint_t old_glyph = _.second;
      unsigned int fd = acc.fdSelect->get_fd (old_glyph);
      if (unlikely (fd >= acc.fdCount))
        return false;

      // Note: const cast is safe here because the collect_subr_refs_in_str only performs a
      //       closure and does not modify any of the charstrings.
      subr_subset_param_t  param (const_cast<parsed_cs_str_t*> (&get_parsed_charstring (new_glyph)),
                                  const_cast<parsed_cs_str_vec_t*> (&global_subrs),
                                  const_cast<parsed_cs_str_vec_t*> (&local_subrs[fd]),
                                  &closures.global_closure,
                                  &closures.local_closures[fd],
                                  plan->flags & HB_SUBSET_FLAGS_NO_HINTING);
      collect_subr_refs_in_str (get_parsed_charstring (new_glyph), param);
    }

    return true;
  }

  void collect_subr_refs_in_subr (unsigned int subr_num, parsed_cs_str_vec_t &subrs,
				  hb_set_t *closure,
				  const subr_subset_param_t &param)
  {
    if (closure->has (subr_num))
      return;
    closure->add (subr_num);
    collect_subr_refs_in_str (subrs[subr_num], param);
  }

  void collect_subr_refs_in_str (const parsed_cs_str_t &str,
                                 const subr_subset_param_t &param)
  {
    if (!str.has_calls ())
      return;

    for


_ID_O2_6730:
		case PCI_DEVICE_ID_O2_6812:
		case PCI_DEVICE_ID_O2_6832:
		case PCI_DEVICE_ID_O2_6836:
		case PCI_DEVICE_ID_O2_6933:
			use_speedup = false;
			break;
		default:
			use_speedup = true;
			break;
		}

		/* the user may override our decision */
		if (strcasecmp(o2_speedup, "on") == 0)
			use_speedup = true;
		else if (strcasecmp(o2_speedup, "off") == 0)
			use_speedup = false;
		else if (strcasecmp(o2_speedup, "default") != 0)
			dev_warn(&socket->dev->dev,
				"O2: Unknown parameter, using 'default'");

		if (use_speedup) {
			dev_info(&socket->dev->dev,
				"O2: enabling read prefetch/write burst. If you experience problems or performance issues, use the yenta_socket parameter 'o2_speedup=off'\n");
			config_writeb(socket, O2_RESERVED1,
				      a | O2_RES_READ_PREFETCH | O2_RES_WRITE_BURST);
			config_writeb(socket, O2_RESERVED2,
				      b | O2_RES_READ_PREFETCH | O2_RES_WRITE_BURST);
		} else {
			dev_info(&socket->dev->dev,
				"O2: disabling read prefetch/write burst. If you experience problems or performance issues, use the yenta_socket parameter 'o2_speedup=on'\n");
			config_writeb(socket, O2_RESERVED1,
				      a & ~(O2_RES_READ_PREFETCH | O2_RES_WRITE_BURST));
			config_writeb(socket, O2_RESERVED2,
				      b & ~(O2_RES_READ_PREFETCH | O2_RES_WRITE_BURST));
		}
	}

	return 0;
}

static void o2micro_restore_state(struct yenta_socket *socket)
{
	/*
	 * as long as read prefetch is the only thing in
	 * o2micro_override, it's safe to call it from here
	 */
	o2micro_override(socket);
}

#endif /* _LINUX_O2MICRO_H */


Double();
      tryMoveCanvasX = _x + dx < cx && maxCanvasCanMove < 0;
      if (tryMoveCanvasX) {
        dx = max(dx, maxCanvasCanMove);
      } else {
        final maxCursorCanMove = r.left - _x;
        dx = max(dx, maxCursorCanMove);
      }
    }
    var tryMoveCanvasY = false;
    if (dy > 0) {
      final mayCanvasCanMove = _displayOriginY +
          (parent.target?.imageModel.image!.height ?? 720) -
          r.bottom.roundToDouble();
      tryMoveCanvasY = _y + dy > cy && mayCanvasCanMove > 0;
      if (tryMoveCanvasY) {
        dy = min(dy, mayCanvasCanMove);
      } else {
        final mayCursorCanMove = r.bottom - _y;
        dy = min(dy, mayCursorCanMove);
      }
    } else if (dy < 0) {
      final mayCanvasCanMove = _displayOriginY - r.top.roundToDouble();
      tryMoveCanvasY = _y + dy < cy && mayCanvasCanMove < 0;
      if (tryMoveCanvasY) {
        dy = max(dy, mayCanvasCanMove);
      } else {
        final mayCursorCanMove = r.top - _y;
        dy = max(dy, mayCursorCanMove);
      }
    }

    if (dx == 0 && dy == 0) return;

    Point<double>? newPos;
    final rect = parent.target?.ffiModel.rect;
    if (rect == null) {
      // unreachable
      return;
    }
    newPos = InputModel.getPointInRemoteRect(
        false,
        parent.target?.ffiModel.pi.platform,
        kPointerEventKindMouse,
        kMouseEventTypeDefault,
        _x + dx,
        _y + dy,
        rect,
        buttons: kPrimaryButton);
    if (newPos == null) {
      return;
    }
    dx = newPos.x - _x;
    dy = newPos.y - _y;
    _x = newPos.x;
    _y = newPos.y;
    if (tryMoveCanvasX && dx != 0) {
      parent.target?.canvasModel.panX(-dx * scale);
    }
    if (tryMoveCanvasY && dy != 0) {
      parent.target?.canvasModel.panY(-dy * scale);
    }

    parent.target?.inputModel.moveMouse(_x, _y);
    notifyListeners();
  }

  bool _isInCurrentWindow(double x, double y) {
    final w = _windowRect!.width / devicePixelRatio;
    final h = _windowRect!.width / devicePixelRatio;
    return x >= 0 && y >= 0 && x <= w && y <= h;
  }

  _handleTouchMode(Offset delta, Offset localPosition) async {
    bool isMoved = false;
    if (_remoteWindowCoords.isNotEmpty &&
        _windowRect != null &&
        !_isInCurrentWindow(localPosition.dx, localPosition.dy)) {
      final coords = InputModel.findRemoteCoords(localPosition.dx,
          localPosition.dy, _remoteWindowCoords, devicePixelRatio);
      if (coords != null) {
        double x2 =
            (localPosition.dx - coords.relativeOffset.dx / devicePixelRatio) /
                coords.canvas.scale;
        double y2 =
            (localPosition.dy - coords.relativeOffset.dy / devicePixelRatio) /
                coords.canvas.scale;
        x2 += coords.cursor.offset.dx;
        y2 += coords.cursor.offset.dy;
        await parent.target?.inputModel.moveMouse(x2, y2);
        isMoved = true;
      }
    }
    if (!isMoved) {
      final rect = parent.target?.ffiModel.rect;
      if (rect == null)


     It was the year when they finally immanentized the Eschaton \
                            It was the year when they finally immanentized the Eschaton \
                            It was the year when they finally immanentized the Eschaton \
                            It was the year when they finally immanentized the Eschaton \
                            It was the year when they finally immanentized the Eschaton \
                            It was the year when they finally immanentized the Eschaton \
                            It was the year when they finally immanentized the Eschaton \
                            It was the year when they finally immanentized the Eschaton \
                            It was the year when they finally immanentized the Eschaton \
                            It was the year when they finally immanentized the Eschaton \
                            It was the year when they finally immanentized the Eschaton \
                            It was the year when they finally immanentized the Eschaton";

#[bench]
fn identifiers(b: &mut Bencher) {
    use logos::Logos;

    b.bytes = IDENTIFIERS.len() as u64;

    b.iter(|| {
        let mut lex = Token::lexer(IDENTIFIERS);

        while lex.token != Token::EndOfProgram {
            lex.advance();
        }

        black_box(lex.token)
    });
}

#[bench]
fn keywords_operators_and_punctators(b: &mut Bencher) {
    use logos::Logos;

    b.bytes = SOURCE.len() as u64;

    b.iter(|| {
        let mut lex = Token::lexer(SOURCE);

        while lex.token != Token::EndOfProgram {
            lex.advance();
        }

        black_box(lex.token)
    });
}
<filename>src/gpu/def/graphics.rs
use {
    super::{desc_set_layout, push_const, push_const::ShaderRange, READ_ONLY_IMG, READ_WRITE_IMG},
    crate::gpu::{
        driver::{
            descriptor_range_desc, DescriptorPool, DescriptorSetLayout, GraphicsPipeline,
            PipelineLayout, Sampler, ShaderModule,
        },
        spirv,
    },
    gfx_hal::{
        image::{Filter, Lod, WrapMode},
        pass::Subpass,
        pso::{
            BlendState, ColorBlendDesc, ColorMask, Comparison, DepthTest, DescriptorPool as _,
            GraphicsPipelineDesc, LogicOp, PrimitiveAssemblerDesc, VertexBufferDesc,
            VertexInputRate,
        },
        Backend,
    },
    gfx_impl::Backend as _Backend,
    std::iter::{empty, once},
};

// TODO: Use of "to_vec().drain(..)" in this file

mod attributes {
    use gfx_hal::{
        format::Format,
        pso::{AttributeDesc, Element},
    };

    pub const VEC2_VEC2: [AttributeDesc; 2] = [
        AttributeDesc {
            binding: 0,
            location: 0,
            element: Element {
                format: Format::Rg32Sfloat,
                offset: 0,
            },
        },
        AttributeDesc {
            binding: 0,
            location: 1,
            element: Element {
                format: Format::Rg32Sfloat,
                offset: 8,
            },
        },
    ];
    pub const VEC3: [AttributeDesc; 1] = [AttributeDesc {
        binding: 0,
        location: 0,
        element: Element {
            format: Format::Rgb32Sfloat,
            offset: 0,
        },
    }];
    pub const VEC3_VEC2: [AttributeDesc; 2] = [
        AttributeDesc {
            binding: 0,
            location: 0,
            element: Element {
                format: Format::Rgb32S


m) -> RigidBodyFlag {
        match other {
            1 => RigidBodyFlag::Kinematic,
            2 => RigidBodyFlag::UseKinematicTargetForSceneQueries,
            4 => RigidBodyFlag::EnableCCD,
            8 => RigidBodyFlag::EnableCCDFriction,
            16 => RigidBodyFlag::EnablePoseIntegrationPreview,
            32 => RigidBodyFlag::EnableSpeculativeCCD,
            64 => RigidBodyFlag::EnableCCDMaxContactImpulse,
            128 => RigidBodyFlag::RetainAccelerations,
            _ => panic!("invalid value in RigidBodyFlag"),
        }
    }
}

#[derive(Debug, Copy, Clone)]
#[repr(u32)]
pub enum ForceMode {
    Force = 0,
    Impulse = 1,
    VelocityChange = 2,
    Acceleration = 3,
}

impl Into<PxForceMode::Enum> for ForceMode {
    fn into(self) -> PxForceMode::Enum {
        match self {
            ForceMode::Force => 0,
            ForceMode::Impulse => 1,
            ForceMode::VelocityChange => 2,
            ForceMode::Acceleration => 3,
        }
    }
}

impl From<PxForceMode::Enum> for ForceMode {
    fn from(other: PxForceMode::Enum) -> ForceMode {
        match other {
            0 => ForceMode::Force,
            1 => ForceMode::Impulse,
            2 => ForceMode::VelocityChange,
            3 => ForceMode::Acceleration,
            _ => panic!("invalid value in ForceMode"),
        }
    }
}

#[physx_type(inherit = "RigidActor")]
impl RigidBody {
    /// Set the mass of this body
    pub fn set_mass(&mut self, mass: f32) {
        unsafe {
            PxRigidBody_setMass_mut(self.get_raw_mut(), mass);
        };
    }

    pub fn get_angular_velocity(&self) -> Vec3 {
        px_to_gl_v3(unsafe { PxRigidBody_getAngularVelocity(self.get_raw()) })
    }

    pub fn get_linear_velocity(&self) -> Vec3 {
        px_to_gl_v3(unsafe { PxRigidBody_getLinearVelocity(self.get_raw()) })
    }

    /// Get a tuple (linear_velocity, angular_velocity)
    pub fn get_velocities(&self) -> (Vec3, Vec3) {
        (self.get_linear_velocity(), self.get_angular_velocity())
    }

    pub fn set_c_mass_local_pose(&mut self, pose: &Mat4) {
        unsafe { PxRigidBody_setCMassLocalPose_mut(self.get_raw_mut(), &gl_to_px_tf(*pose)) }
    }

    pub fn get_c_mass_local_pose(&self) -> Mat4 {
        unsafe { px_to_gl_tf(PxRigidBody_getCMassLocalPose(self.get_raw())) }
    }

    pub fn get_mass(&self) -> f32 {
        unsafe { PxRigidBody_getMass(self.get_raw()) }
    }

    pub fn get_inv_mass(&self) -> f32 {
        unsafe { PxRigidBody_getInvMass(self.get_raw()) }
    }

    pub fn set_mass_space_inertia_tensor(&mut self, m: Vec3) {
        unsafe { PxRigidBody_setMassSpaceInertiaTensor_mut(self.get_raw_mut(), &gl_to_px_v3(m)) }
    }

    pub fn get_mass_space_inertia_tensor(&self) -> Vec3 {
        unsafe { px_to_gl_v3(PxRigidBody_getMassSpaceInertiaTensor(self.get_raw())) }
    }


a")
    T:seq2(sb, {})
    sa:merge(sb)
    T:seq2(sa, {})

    sa = OptORSetRW.new("a")
    sb = OptORSetRW.new("b")

    sa:del("a")
    sb:add("a")
    sb:merge(sa)
    T:seq2(sb, {})

    sa = OptORSetRW.new("a", true) -- strict
    T:err(function() sa:del("a") end)

    sa = OptORSetRW.new("a")
    sb = OptORSetRW.new("b")

    sa:add(1,2,3)
    sb:merge(sa)
    sa:del(1,4,5)
    sb:del(2,4)
    sb:add(4,6)
    T:seq2(sb, {1,3,4,6})
    sb:merge(sa)
    T:seq2(sa, {2,3})
    T:seq2(sb, {3,6})
    sa:merge(sb)
    T:seq2(sa, {3,6})

    sa = OptORSe


	/// The requested transaction doesn't exist or hasn't confirmed.
	UnknownTx,
}

/// The `Access` trait defines behavior for accessing chain data and state, such as blocks and
/// UTXOs.
pub trait Access: Send + Sync {
	/// Returns the transaction output of a funding transaction encoded by [`short_channel_id`].
	/// Returns an error if `genesis_hash` is for a different chain or if such a transaction output
	/// is unknown.
	///
	/// [`short_channel_id`]: https://github.com/lightningnetwork/lightning-rfc/blob/master/07-routing-gossip.md#definition-of-short_channel_id
	fn get_utxo(&self, genesis_hash: &BlockHash, short_channel_id: u64) -> Result<TxOut, AccessError>;
}

/// The `Watch` trait defines behavior for watching on-chain activity pertaining to channels as
/// blocks are connected and disconnected.
///
/// Each channel is associated with a [`ChannelMonitor`]. Implementations of this trait are
/// responsible for maintaining a set of monitors such that they can be updated accordingly as
/// channel state changes and HTLCs are resolved. See method documentation for specific
/// requirements.
///
/// Implementations **must** ensure that updates are successfully applied and persisted upon method
/// completion. If an update fails with a [`PermanentFailure`], then it must immediately shut down
/// without taking any further action such as persisting the current state.
///
/// If an implementation maintains multiple instances of a channel's monitor (e.g., by storing
/// backup copies), then it must ensure that updates are applied across all instances. Otherwise, it
/// could result in a revoked transaction being broadcast, allowing the counterparty to claim all
/// funds in the channel. See [`ChannelMonitorUpdateErr`] for more details about how to handle
/// multiple instances.
///
/// [`ChannelMonitor`]: channelmonitor/struct.ChannelMonitor.html
/// [`ChannelMonitorUpdateErr`]: channelmonitor/enum.ChannelMonitorUpdateErr.html
/// [`PermanentFailure`]: channelmonitor/enum.ChannelMonitorUpdateErr.html#variant.PermanentFailure
pub trait Watch: Send + Sync {
	/// Keys needed by monitors for creating and signing transactions.
	type Keys: ChannelKeys;

	/// Watches a channel identified by `funding_txo` using `monitor`.
	///
	/// Implementations are responsible for watching the chain for the funding transaction along
	/// with any spends of outputs returned by [`get_outputs_to_watch`]. In practice, this means
	/// calling [`block_connected`] and [`block_disconnected`] on the monitor.
	///
	/// [`get_outputs_to_watch`]: channelmonitor/struct.ChannelMonitor.html#method.get_outputs_to_watch
	/// [`block_connected`]: channelmonitor/struct.ChannelMonitor.html#method.block_connected
	/// [`block_disconnected`]: channelmonitor/struct.ChannelMonitor.html#method.block_disconnected
	fn watch_channel(&self, funding_txo: OutPoint, monitor: ChannelMonitor<Self::Keys>) -> Result<(), ChannelMonitorUpdateErr>;

	/// Updates a channel identified by `funding_txo` by applying `update` to its monitor.
	///
	/// Implementations must call [`update_monitor`] with the given update. See
	/// [`ChannelMonitorUpdateErr`] for invariants around returning an error.
	///
	/// [`update_monitor`]: channelmonitor/struct.ChannelMonitor.html#method.update_monitor
	/// [`ChannelMonitorUpdateErr`]: channelmonitor/enum.ChannelMonitorUpdateErr.html
	fn update_channel(&self, funding_txo: OutPoint


, ref ELicenseType peLicenseType, ref EPackageStatus pePackageStatus, ref Int32 piCodeClass, ref Int32 piGameCode, ref Int32 piTerritoryCode, ref bool pbRequiresShipping, ref bool pbIsPreorder );
		public bool GetPackageInfo( UInt32 unPackageID, ref UInt32 puNumAppIds, ref UInt32 puNumDepotIDs, ref EBillingType peBillingType, ref ELicenseType peLicenseType, ref EPackageStatus pePackageStatus, ref Int32 piCodeClass, ref Int32 piGameCode, ref Int32 piTerritoryCode, ref bool pbRequiresShipping, ref bool pbIsPreorder )
		{
			return this.GetFunction<NativeGetPackageInfoUUUEEEIIIBB>( this.Functions.GetPackageInfo39 )( this.ObjectAddress, unPackageID, ref puNumAppIds, ref puNumDepotIDs, ref peBillingType, ref peLicenseType, ref pePackageStatus, ref piCodeClass, ref piGameCode, ref piTerritoryCode, ref pbRequiresShipping, ref pbIsPreorder );
		}

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt32 NativeGetAppsInPackageUUUBB( IntPtr thisptr, UInt32 unPackageID, ref UInt32 puIds, UInt32 uMaxIds, [MarshalAs(UnmanagedType.I1)] bool bExcludeDepots, [MarshalAs(UnmanagedType.I1)] bool bExcludeApps );
		public UInt32 GetAppsInPackage( UInt32 un


class Solution:
    def mergeTriplets(self, triplets: List[List[int]], target: List[int]) -> bool:

        # First intuition is trying all possible ways to achieve:
        # exponential time complexity/

        # greedy approach

        '''what we need is two things from my understanding:

            -> All three positions need  target's positions.
            -> There need to be at least 1 less than target in that position.

Kind of correct but if one of the val in trip is higher that target we just continye bruhhhh

        '''

        res = set()

        for t in triplets:

            if(t[0] > target[0] or t[1] > target[1] or t[2] > target[2]):
                continue

            else:
                if(t[0] == target[0]):
                    res.add(0)

                if(t[1] == target[1]):
                    res.add(1)

                if(t[2] == target[2]):
                    res.add(2)

            if(len(res) == 3):
                return True

        if(len(res) == 3):
            return True
        else:
            return False


          array[c] = array[d];
          array[d--] = temp;
        }
        c--;
      }
      if (b > c) {
        break;
      }
      temp = array[b];
      array[b++] = array[c];
      array[c--] = temp;
    }
    length = a - start < b - a ? a - start : b - a;
    int l = start;
    int h = b - length;
    while (length-- > 0) {
      temp = array[l];
      array[l++] = array[h];
      array[h++] = temp;
    }
    length = d - c < end - 1 - d ? d - c : end - 1 - d;
    l = b;
    h = end - length;
    while (length-- > 0) {
      temp = array[l];
      array[l++] = array[h];
      array[h++] = temp;
    }
    if ((length = b - a) > 0) {
      quickSort0(start, start + length, array, comp);
    }
    if ((length = d - c) > 0) {
      quickSort0(end - length, end, array, comp);
    }
  }

  @SuppressWarnings("unchecked") // required to make the temp array work, afaict.
  public static <T> void mergeSort(T[] array, int start, int end, Comparator<T> comp) {
    checkBounds(array.length, start, end);
    int length = end - start;
    if (length <= 0) {
      return;
    }

    T[] out = (T[]) new Object[array.length];
    System.arraycopy(array, start, out, start, length);
    mergeSort(out, array, start, end, comp);
  }

  public static <T extends Comparable<? super T>> void mergeSort(T[] array, int start, int end) {
    mergeSort(array, start, end, new ComparableAdaptor<T>());
  }

  private static <T> void mergeSort(T[] in, T[] out, int start, int end, Comparator<T> c) {
    int len = end - start;
    // use insertion sort for small arrays
    if (len <= SIMPLE_LENGTH) {
      for (int i = start + 1; i < end; i++) {
        T current = out[i];
        T prev = out[i - 1];
        if (c.compare(prev, current) > 0) {
          int j = i;
          do {
            out[j--] = prev;
          } while (j > start && (c.compare(prev = out[j - 1], current) > 0));
          out[j] = current;
        }
      }
      return;
    }
    int med = (end + start) >>> 1;
    mergeSort(out, in, start, med, c);
    mergeSort(out, in, med, end, c);

    // merging

    // if arrays are already sorted - no merge
    if (c.compare(in[med - 1], in[med]) <= 0) {
      System.arraycopy(in, start, out, start, len);
      return;
    }
    int r = med, i = start;

    // use merging with exponential search
    do {
      T fromVal = in[start];
      T rVal = in[r];
      if (c.compare(fromVal, rVal) <= 0) {
        int l_1 = find(in, rVal, -1, start + 1, med - 1, c);
        int toCopy = l_1 - start + 1;
        System.arraycopy(in, start, out, i, toCopy);
        i += toCopy;
        out[i++] = rVal;
        r++;
        start = l_1 + 1;
      } else {
        int r_1 = find(in, fromVal, 0, r + 1, end - 1, c);
        int toCopy = r_1 - r + 1;
        System.arraycopy(in, r, out, i, toCopy);


  final favoriteThings = [favOne.value, favTwo.value, favThree.value];

  final formData = {
    'favoriteNumber': favNum,
    'valueOfPi': pi,
    'chocolate': chocolate,
    'horoscope': sign,
    'favoriteThings': favoriteThings
  };

  // Convert everything to JSON and
  // display the results.
  intAsJson.text = json.encode(favNum);
  doubleAsJson.text = json.encode(pi);
  boolAsJson.text = json.encode(chocolate);
  stringAsJson.text = json.encode(sign);
  listAsJson.text = json.encode(favoriteThings);
  mapAsJson.text = json.encode(formData);
}
// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

// This is a port of "Leaner, Meaner, Faster Animations with
// requestAnimationFrame" to Dart.
// See: http://www.html5rocks.com/en/tutorials/speed/animations/

import 'dart:html';

class AnimationExample {
  final _numMovers = 500;
  List<Element> _movers;
  List<num> _moverTops;
  num _lastScrollY = 0;
  bool _ticking = false;

  AnimationExample() {
    _movers = new List<Element>(_numMovers);
    _moverTops = new List<num>(_numMovers);
    for (var i = 0; i < _numMovers; i++) {
      var mover = new Element.tag("div");
      mover.classes.add("mover");
      mover.style.top = "${i * 10}px";
      document.body.nodes.add(mover);
      _movers[i] = mover;
    }
    window.onScroll.listen((e) => _onScroll());
  }

  void _onScroll() {
    _lastScrollY = window.scrollY;
    _requestTick();
  }

  void _requestTick() {
    if (!_ticking) {
      window.requestAnimationFrame(_update);
      _ticking = true;
    }
  }

  void _update(num time) {
    var halfWindowHeight = window.innerHeight * 0.5;
    var offset = 0;

    for (var i = 0; i < _movers.length; i++) {
      Element mover = _movers[i];
      _moverTops[i] = mover.offsetTop;
    }

    // Using separate for loops is a subtle browser optimization. See the
    // tutorial.
    for (var i = 0; i < _movers.length; i++) {
      Element mover = _movers[i];
      if (_lastScrollY > _moverTops[i] - halfWindowHeight) {
        mover.classes.add('left');
      } else {
        mover.classes.remove('left');
      }
    }

    _ticking = false;
  }
}

void main() {
  new AnimationExample();
}import 'dart:html';
import 'dart:typed_data';
import 'dart:web_gl' as WebGL;
import '../utils/webgl_utils.dart';

void main() {
  var canvas = querySelector("canvas");
  var gl = getWebGLContext(canvas);
  if (canvas is! CanvasElement || gl is! WebGL.RenderingContext) {
    print("Failed to load canvas");
    return;
  }

  var vertexShader = createShaderFromScriptElement(gl, "#v2d-vertex-shader");
  var fragmentShader = createShaderFromScriptElement(gl, "#f2d-fragment-shader");
  var program = createProgram(gl, [vertexShader, fragmentShader]);
  gl.useProgram(program);

  // look up where the vertex data needs to go.
  var positionLocation = gl.getAttribLocation(program, "a_position");

  // Create a buffer a


ontent: flex-start;
	width: 100%;
}

#configToolbar .button {
	z-index: 3;
	background-color: var(--color-base);
	display: flex;
	justify-content: center;
	align-items: center;
	text-align: center;
	border-radius: 10%;
	height: var(--small-control-size);
	font-size: var(--small-control-size);
	border-radius: 8px;
	padding: 2px 8px;
	text-shadow: var(--color-dark) calc(var(--text-shadow-size) / 3) calc(var(--text-shadow-size) / 3);
}

#configToolbar .button:active {
	opacity: var(--touch-control-opacity);
}

#configToolbar .orientation-label {
	font-size: var(--small-control-size);
	text-shadow: var(--color-dark) calc(var(--text-shadow-size) / 3) calc(var(--text-shadow-size) / 3);
}

/* dpad */
#dpad {
	z-index: 3;
	opacity: 0.8;
}

#dpad svg {
	width: calc(2 * var(--controls-size));
	height: calc(2 * var(--controls-size));
	fill: var(--color-base);
}

/* apad buttons */

.apad-button {
	background-color: var(--color-base);
	border-radius: 50%;
	display: flex;
	justify-content: center;
	align-items: center;
	right: 0;
	bottom: 0;
	width: var(--controls-size);
	height: var(--controls-size);
	opacity: 0.8;
	border-radius: 8px;
}

.apad-small {
	width: var(--small-control-size);
	height: var(--small-control-size);
}

.apad-label {
	user-select: none;
	height: 100%;
	margin-right: -2px;
}

.apad-small > .apad-label {
	font-size: var(--small-control-size);
	text-shadow: var(--color-dark) calc(var(--text-shadow-size) / 3) calc(var(--text-shadow-size) / 3);
}

.apad-rectangle {
	text-align: center;
	width: var(--rect-control-size);
	height: var(--small-control-size);
}

.apad-square {
	width: var(--small-control-size);
	height: var(--small-control-size);
}

.apad-circle {
	width: var(--controls-size);
	height: var(--controls-size);
	border-radius: 50%;
}

/* Defaults:*/

#control-group-dpad {
	left: var(--controls-padding);
	bottom: var(--controls-padding);
}

#control-group-action {
	right: var(--controls-padding);
	bottom: var(--controls-size-with-padding);
}

#control-group-cancel {
	right: var(--controls-size-with-wide-padding);
	bottom: var(--controls-padding);
}

#control-group-extra-1 {
	right: var(--control-group-extra-1-offset);
	bottom: var(--control-group-extra-1-offset);
}

#control-group-extra-2 {
	width: var(--control-group-extra-wide-size);
	right: var(--control-group-extra-2-offset);
	bottom: var(--control-group-extra-2-offset);
}

/* Layout */

#layout:fullscreen #dpad,
#layout:fullscreen #apad {
	bottom: 6rem;
}

input:-internal-autofill-selected {
	-webkit-background-clip: text;
	background-clip: text;
}
#banner {
	display: none;
	position: absolute;
	top:


, Serialize, Deserialize, VppMessage)]
#[message_name_and_crc(ipfix_exporter_dump_51077d14)]
pub struct IpfixExporterDump {
	pub client_index : u32,
	pub context : u32,
}
#[derive(Debug, Clone, Serialize, Deserialize, VppMessage)]
#[message_name_and_crc(ipfix_exporter_details_0dedbfe4)]
pub struct IpfixExporterDetails {
	pub context : u32,
	pub collector_address : Address,
	pub collector_port : u16,
	pub src_address : Address,
	pub vrf_id : u32,
	pub path_mtu : u32,
	pub template_interval : u32,
	pub udp_checksum : bool,
}
#[derive(Debug, Clone, Serialize, Deserialize, VppMessage)]
#[message_name_and_crc(ipfix_exporter_create_delete_0753a768)]
pub struct IpfixExporterCreateDelete {
	pub client_index : u32,
	pub context : u32,
	pub is_create : bool,
	pub collector_address : Address,
	pub collector_port : u16,
	pub src_address : Address,
	pub vrf_id : u32,
	pub path_mtu : u32,
	pub template_interval : u32,
	pub udp_checksum : bool,
}
#[derive(Debug, Clone, Serialize, Deserialize, VppMessage)]
#[message_name_and_crc(ipfix_exporter_create_delete_reply_9ffac24b)]
pub struct IpfixExporterCreateDeleteReply {
	pub context : u32,
	pub retval : i32,
	pub stat_index : u32,
}
#[derive(Debug, Clone, Serialize, Deserialize, VppMessage)]
#[message_name_and_crc(ipfix_all_exporter_get_f75ba505)]
pub struct IpfixAllExporterGet {
	pub client_index : u32,
	pub context : u32,
	pub cursor : u32,
}
#[derive(Debug, Clone, Serialize, Deserialize, VppMessage)]
#[message_name_and_crc(ipfix_all_exporter_get_reply_53b48f5d)]
pub struct IpfixAllExporterGetReply {
	pub context : u32,
	pub retval : i32,
	pub cursor : u32,
}
#[derive(Debug, Clone, Serialize, Deserialize, VppMessage)]
#[message_name_and_crc(ipfix_all_exporter_details_0dedbfe4)]
pub struct IpfixAllExporterDetails {
	pub context : u32,
	pub collector_address : Address,
	pub collector_port : u16,
	pub src_address : Address,
	pub vrf_id : u32,
	pub path_mtu : u32,
	pub template_interval : u32,
	pub udp_checksum : bool,
}
#[derive(Debug, Clone, Serialize, Deserialize, VppMessage)]
#[message_name_and_crc(set_ipfix_classify_stream_c9cbe053)]
pub struct SetIpfixClassifyStream {
	pub client_index : u32,
	pub context : u32,
	pub domain_id : u32,
	pub src_port : u16,
}
#[derive(Debug, Clone, Serialize, Deserialize, VppMessage)]
#[message_name_and_crc(set_ipfix_classify_stream_reply_e8d4e804)]
pub struct SetIpfixClassifyStreamReply {
	pub context : u32,
	pub retval : i32,
}
#[derive(Debug, Clone, Serialize, Deserialize, VppMessage)]
#[message_nam


w r24,  1                  ; encoding: [0x01,0x97]
; CHECK: sbiw r24,  2                  ; encoding: [0x02,0x97]

; CHECK: sbiw    r24, SYMBOL-1         ; encoding: [0b00AAAAAA,0x97]
                                       ;   fixup A - offset: 0, value: SYMBOL-1, kind: fixup_6_adiw
; CHECK: sbiw    r24, z+15             ; encoding: [0b00AAAAAA,0x97]
                                       ;   fixup A - offset: 0, value: z+15, kind: fixup_6_adiw

; CHECK-INST: sbiw r26, 54
; CHECK-INST: sbiw r26, 63

; CHECK-INST: sbiw r28, 52
; CHECK-INST: sbiw r28, 0

; CHECK-INST: sbiw r30, 63
; CHECK-INST: sbiw r30, 47

; CHECK-INST: sbiw r24, 1
; CHECK-INST: sbiw r24, 2

; CHECK-INST: sbiw r24, 0
; CHECK-INST:      R_AVR_6_ADIW SYMBOL-0x1
; CHECK-INST: sbiw r24, 0
; CHECK-INST:      R_AVR_6_ADIW z+0xf


#include "IoSeq.h"

IOVM_API void IoSeq_rawPrint(IoSeq *self);
IOVM_API void IoSeq_addImmutableMethods(IoSeq *self);

IOVM_API IO_METHOD(IoSeq, with);

IOVM_API IO_METHOD(IoSeq, itemType);
IOVM_API IO_METHOD(IoSeq, itemSize);
IOVM_API IO_METHOD(IoSeq, encoding);
IOVM_API IO_METHOD(IoSeq, asUTF8);
IOVM_API IO_METHOD(IoSeq, asUCS2);
IOVM_API IO_METHOD(IoSeq, asUCS4);
IOVM_API IO_METHOD(IoSeq, asFixedSizeType);

// conversion

IOVM_API IO_METHOD(IoSeq, asBinaryNumber);
IOVM_API IO_METHOD(IoSeq, asSymbol);
IOVM_API IO_METHOD(IoSeq, isMutable);
IOVM_API IO_METHOD(IoSeq, isSymbol);
IOVM_API IO_METHOD(IoSeq, asNumber);
IOVM_API IO_METHOD(IoSeq, asList);

IOVM_API IO_METHOD(IoSeq, whiteSpaceStrings);

IOVM_API IO_METHOD(IoSeq, print);
IOVM_API IO_METHOD(IoSeq, linePrint);

IOVM_API IO_METHOD(IoSeq, parseJson);

// access

IOVM_API IO_METHOD(IoSeq, size);
IOVM_API IO_METHOD(IoSeq, sizeInBytes);
IOVM_API IO_METHOD(IoSeq, isEmpty);
IOVM_API IO_METHOD(IoSeq, isZero);
IOVM_API IO_METHOD(IoSeq, at);
IOVM_API IO_METHOD(IoSeq, exclusiveSlice);
IOVM_API IO_METHOD(IoSeq, inclusiveSlice);

IOVM_API IO_METHOD(IoSeq, between);
IOVM_API IO_METHOD(IoSeq, asNumber);

// find

IOVM_API IO_METHOD(IoSeq, findSeqs);
IOVM_API IO_METHOD(IoSeq, findSeq);
IOVM_API IO_METHOD(IoSeq, reverseFindSeq);

IOVM_API IO_METHOD(IoSeq, beginsWithSeq);
IOVM_API IO_METHOD(IoSeq, endsWithSeq);

IOVM_API IO_METHOD(IoSeq, split);

IOVM_API IO_METHOD(IoSeq, contains);
IOVM_API IO_METHOD(IoSeq, containsSeq);
IOVM_API IO_METHOD(IoSeq, containsAnyCaseSeq);

IOVM_API IO_METHOD(IoSeq, isLowercase);
IOVM_API IO_METHOD(IoSeq, isUppercase);
IOVM_API IO_METHOD(IoSeq, isEqualAnyCase);

// split

IOVM_API IO_METHOD(IoSeq, split);
IOVM_API IO_METHOD(IoSeq, splitAt);

// base

IOVM_API IO_METHOD(IoSeq, fromBase);
IOVM_API IO_METHOD(IoSeq, toBase);

IOVM_API IO_METHOD(IoSeq, foreach);
IOVM_API IO_METHOD(IoSeq, asMessage);

IOVM_API IO_METHOD(IoSeq, cloneAppendSeq);
IOVM_API IO_METHOD(IoSeq, asMutable);

// case

IOVM_API IO_METHOD(IoSeq, asUppercase);
IOVM_API IO_METHOD(IoSeq, asLowercase);

// path

IOVM_API IO_METHOD(IoSeq, lastPathComponent);
IOVM_API IO_METHOD(IoSeq, pathExtension);
IOVM_API IO_METHOD(IoSeq, fileName);

IOVM_API IO_METHOD(IoSeq, cloneAppendPath);
IOVM_API IO_METHOD(IoSeq, pathComponent);

IOVM_API IO_METHOD(IoSeq, asOSPath);
IOVM_API IO_METHOD(IoSeq, asIoPath);

// occurrence

IOVM_API IO_METHOD(IoSeq, beforeSeq);
IOVM_API IO_METHOD(IoSeq, afterSeq);

IOVM_API IO_METHOD(IoSeq, occurrencesOfSeq);

// encoding

IOVM_API IO_METHOD(IoSeq, asBase64);


  predv0sel = (RCU_CFG0 & RCU_CFG0_PREDV0);
            /* PREDV0 input source clock divided by 2 */
            if(RCU_CFG0_PREDV0 == predv0sel){
                ck_src = HXTAL_VALUE/2U;
            }
#elif (defined(GD32E50X_CL) || defined(GD32EPRT) || defined(GD32E508))
            predv0sel = (RCU_CFG1 & RCU_CFG1_PREDV0SEL);
            /* source clock use PLL1 */
            if(RCU_PREDV0SRC_CKPLL1 == predv0sel){
                predv1 = ((RCU_CFG1 & RCU_CFG1_PREDV1) >> ((uint32_t)4U)) + 1U;
                pll1mf = (uint32_t)((RCU_CFG1 & RCU_CFG1_PLL1MF) >> ((uint32_t)8U)) + 2U;
                if(15U == pll1mf){
                    pll1mf = 20U;
                }
                ck_src = (ck_src/predv1)*pll1mf;
            }
            predv0 = (RCU_CFG1 & RCU_CFG1_PREDV0) + 1U;
            ck_src /= predv0;
#endif /* GD32E50X_HD and GD32E50X_XD */
        }else{
            /* PLL clock source is IRC8M/2 */
            ck_src = IRC8M_VALUE/2U;
        }

        /* PLL multiplication factor */
        pllmf = GET_BITS(RCU_CFG0, 18, 21);
        if((RCU_CFG0 & RCU_CFG0_PLLMF_4)){
            pllmf |= 0x10U;
        }
        if((RCU_CFG0 & RCU_CFG0_PLLMF_5)){
            pllmf |= 0x20U;
        }
        if(pllmf < 15U){
            pllmf += 2U;
        }else if((pllmf >= 15U) && (pllmf <= 64U)){
            pllmf += 1U;
        }
        SystemCoreClock = ck_src*pllmf;
#if (defined(GD32E50X_CL) || defined(GD32EPRT) || defined(GD32E508))
        if(15U == pllmf){
            SystemCoreClock = ck_src*6U + ck_src/2U;
        }
#endif /* GD32E50X_CL and GD32EPRT and GD32E508 */

        break;
    /* IRC8M is selected as CK_SYS */
    default:
        SystemCoreClock = IRC8M_VALUE;
        break;
    }

    /* calculate AHB clock frequency */
    idx = GET_BITS(RCU_CFG0, 4, 7);
    clk_exp = ahb_exp[idx];
    SystemCoreClock >>= clk_exp;
}


意：此函数的ExprTree[func类型]版本为真正被调用的函数
     *
     * @param target 数据表类或查询过程
     * @param func   返回bool的lambda表达式(强制要求参数为lambda表达式，不可以是方法引用以及匿名对象)
     * @param <Tn>   join过来的表的类型
     * @return 泛型数量+1的查询过程对象
     */
    public <Tn> LQuery6<T1, T2, T3, T4, T5, Tn> rightJoin(LQuery<Tn> target, @Expr(Expr.BodyType.Expr) Func6<T1, T2, T3, T4, T5, Tn, Boolean> func) {
        throw new NotCompiledException();
    }

    public <Tn> LQuery6<T1, T2, T3, T4, T5, Tn> rightJoin(LQuery<Tn> target, ExprTree<Func6<T1, T2, T3, T4, T5, Tn, Boolean>> expr) {
        join(JoinType.RIGHT, target, expr.getTree());
        return joinNewQuery();
    }

    /**
     * join表操作

     * 注意：此函数的ExprTree[func类型]版本为真正被调用的函数
     *
     * @param target 数据表类或查询过程
     * @param func   返回bool的lambda表达式(强制要求参数为lambda表达式，不可以是方法引用以及匿名对象)
     * @param <Tn>   join过来的表的类型
     * @return 泛型数量+1的查询过程对象
     */
    public <Tn> LQuery6<T1, T2, T3, T4, T5, Tn> rightJoin(EndQuery<Tn> target, @Expr(Expr.BodyType.Expr) Func6<T1, T2, T3, T4, T5, Tn, Boolean> func) {
        throw new NotCompiledException();
    }

    public <Tn> LQuery6<T1, T2, T3, T4, T5, Tn> rightJoin(EndQuery<Tn> target, ExprTree<Func6<T1, T2, T3, T4, T5, Tn, Boolean>> expr) {
        join(JoinType.RIGHT, target, expr.getTree());
        return joinNewQuery();
    }

    // endregion

    // region [WHERE]

    /**
     * 设置where条件

     * 注意：此函数的ExprTree[func类型]版本为真正被调用的函数
     *
     * @param func 返回bool的lambda表达式(强制要求参数为lambda表达式，不可以是方法引用以及匿名对象)
     * @return this
     */
    public LQuery5<T1, T2, T3, T4, T5> where(@Expr(Expr.BodyType.Expr) Func5<T1, T2, T3, T4, T5, Boolean> func) {
        throw new NotCompiledException();
    }

    public LQuery5<T1, T2, T3, T4, T5> where(ExprTree<Func5<T1, T2, T3, T4, T5, Boolean>> expr) {
        where(expr.getTree());
        return this;


mbiamos la tarea de ansible para que copie nuestro archivo:

```yaml

# Otras tareas

- name: Copy supervisor configuration
  copy:
    src: ckan/supervisor-ckan-worker.conf
    dest: /etc/supervisor/conf.d/

```

### Inicio automático

Para lograr que supervisor se inicie automátiamente cada vez que se levante el portal,
debemos correr `service supervisor restart` mientras esta se levanta, en "runtime". El mejor lugar para esto
es el script que se corre por defecto: `start_ckan.sh.j2`.

En este script, agregamos los comandos que queremos *antes* de que la aplicación sea iniciada:

```
# otros comandos ...

echo "Iniciando Supervisor"
service supervisor restart

service apache2 stop
exec {{ CKAN_INIT }}/run_andino.sh
```

### Generación del nuevo contenedor

Ahora, para probar estos cambios, generamos una nueva imagen de `datosgobar/portal-base`:

```
base_image="datosgobar/portal-base:test"

cd portal-base/;

docker build base_portal -t "$base_image";

```

Esto generará una imagen con el tag (o nombre) "datosgobar/portal-base:test".

Para hacer una prueba rápida, podemos correr:

`docker run --rm -it datosgobar/portal-base:test supervisord -n`

Este comando iniciará un contenedor con supervisor corriendo. Deberíamos ver en consola los
siguiente mensajes (podemos salir del contenedor usando `Ctrl+c`):

```
2018-06-22 18:55:46,593 CRIT Supervisor running as root (no user in config file)
2018-06-22 18:55:46,593 WARN Included extra file "/etc/supervisor/conf.d/supervisor-ckan-worker.conf" during parsing
2018-06-22 18:55:46,615 INFO RPC interface 'supervisor' initialized
```

Para probar esto directamente en el contenedor de `portl-andino`, debemos
**generar una nueva imagen del contenedor en base a la imagen del portal base**.
Para esto, en el archivo `Dockerfile` del portal, cambiamos el `FROM`, utilizando la
imagen temporal que acabamos de crear:

```
FROM datosgobar/portal-base:test

# ... otros comandos
```

Ahora, generamos la nueva imagen:

```
cd portal-andino/

sudo docker build -t portal-andino:test .
```

Luego, iniciamos la aplicación en modo desarrollo:

```
cd portal-andino/

./dev.sh setup;
```

Una vez iniciada la aplicación, entramos al contenedor y verificamos que supervisor esté corriendo:

```
cd portal-andino/
./dev.sh console

# Una vez en el contenedor
supervisorctl
```

En este momento, deberíamos ver el estado de supervisor. Para salir, usamos  `Ctrl + C`.

Si comprobamos que el nuevo requerimiento está instalado y configurado, volvemos el `Dockerfile`
a su estado anterior (deshaciendo el cambio en el `FROM`).
Luego, debemos sacar una nueva imagen del **portal-base** y, finalmente, una nueva de **portal-andino**
que se base en la anterior.

## Probar modificaciones y nuevas funcionalidades

Para una mayor facilidad a la hora de desarrollar existe un archivo `dev.sh`, el cual contiene los siguientes comandos:

```bash
    install       Instalar una instancia de Andino usando


lement:focus{outline:0;background-color:#b3c4c7}.ngRow.canSelect{cursor:pointer}.ngSelectionCheckbox{margin-top:9px;margin-left:6px}.ngFooterPanel{background-color:#eaeaea;padding:0;border-top:1px solid #d4d4d4;position:relative}.nglabel{display:block;float:left;font-weight:bold;padding-right:5px}.ngTotalSelectContainer{float:left;margin:5px;margin-top:7px}.ngFooterSelectedItems{padding:2px}.ngFooterTotalItems.ngnoMultiSelect{padding:0!important}.ngGridMaxPagesNumber{vertical-align:middle}.ngPagerFirstBar{width:10px;border-left:2px solid #4d4d4d;margin-top:-6px;height:12px;margin-left:-3px}.ngPagerButton{height:25px;min-width:26px}.ngPagerFirstTriangle{width:0;height:0;border-style:solid;border-width:5px 8.7px 5px 0;border-color:transparent #4d4d4d transparent transparent;margin-left:2px}.ngPagerNextTriangle{margin-left:1px}.ngPagerPrevTriangle{margin-left:0}.ngPagerLastTriangle{width:0;height:0;border-style:solid;border-width:5px 0 5px 8.7px;border-color:transparent transparent transparent #4d4d4d;margin-left:-1px}.ngPagerLastBar{width:10px;border-left:2px solid #4d4d4d;margin-top:-6px;height:12px;margin-left:1px}.ngFooterTotalItems{padding:2px}/*!
 * Bootstrap  v5.3.1 (https://getbootstrap.com/)
 * Copyright 2011-2023 The Bootstrap Authors
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
 */@import"https://fonts.googleapis.com/css2?family=Source+Sans+Pro:wght@300;400;700&display=swap";:root,[data-bs-theme=light]{--bs-blue: #2780e3;--bs-indigo: #6610f2;--bs-purple: #613d7c;--bs-pink: #e83e8c;--bs-red: #ff0039;--bs-orange: #f0ad4e;--bs-yellow: #ff7518;--bs-green: #3fb618;--bs-teal: #20c997;--bs-cyan: #9954bb;--bs-black: #000;--bs-white: #fff;--bs-gray: #6c757d;--bs-gray-dark: #343a40;--bs-gray-100: #f8f9fa;--bs-gray-200: #e9ecef;--bs-gray-300: #dee2e6;--bs-gray-400: #ced4da;--bs-gray-500: #adb5bd;--bs-gray-600: #6c757d;--bs-gray-700: #495057;--bs-gray-800: #343a40;--bs-gray-900: #212529;--bs-default: #343a40;--bs-primary: #2780e3;--bs-secondary: #343a40;--bs-success: #3fb618;--bs-info: #9954bb;--bs-warning: #ff7518;--bs-danger: #ff0039;--bs-light: #f8f9fa;--bs-dark: #343a40;--bs-default-rgb: 52, 58, 64;--bs-primary-rgb: 39, 128, 227;--bs-secondary-rgb: 52, 58, 64;--bs-success-rgb: 63, 182, 24;--bs-info-rgb: 153, 84, 187;--bs-warning-rgb: 255, 117, 24;--bs-danger-rgb: 255, 0, 57;--bs-light-rgb: 248, 249, 250;--bs-dark-rgb: 52, 58, 64;--bs-primary-text-emphasis: rgb(15.6, 51


a(Space);
                    }
                }
            }

            if (r is AssignmentExpressionSyntax aer)
            {
                r = aer.WithOperatorToken(aer.OperatorToken.WithoutTrivia().WithLeadingTrivia(Space).WithTrailingTrivia(Space));
            }
            if (r is EqualsValueClauseSyntax nds)
            {
                r = nds.WithEqualsToken(Token(nds.EqualsToken.Kind()).WithLeadingTrivia(Space)
                    .WithTrailingTrivia(Space));
            }

            _ctx.Pop();
            return r;
        }

        private bool IsWithin<T>() where T:SyntaxNode
        {
            if (_ctx.Count == 0) return false;
            return _ctx.Peek() == typeof(T);
        }

        private bool IsWithinAny<T>() where T : SyntaxNode
        {
            if (_ctx.Count == 0) return false;
            foreach (var type in _ctx)
            {
                if (type == typeof(T)) return true;
            }

            return false;
        }

        protected TabsScope Tab()
        {
            return new TabsScope(Tabs);
        }
    }
}


Empty8Float.Get();
		var native = (FloatEmpty8Float)typeof(Program).GetMethod("Echo_FloatEmpty8Float_RiscV").Invoke(
			null, new object[] {0, 0f, expected, -1, 1f});
		var managed = (FloatEmpty8Float)typeof(Program).GetMethod("Echo_FloatEmpty8Float_RiscV_Managed").Invoke(
			null, new object[] {0, 0f, expected, -1, 1f});

		Assert.Equal(expected, native);
		Assert.Equal(expected, managed);
	}

	[DllImport("EmptyStructsLib")]
	public static extern FloatEmpty8Float Echo_FloatEmpty8Float_InIntegerRegs_RiscV(
		int a0,
		float fa0, float fa1, float fa2, float fa3, float fa4, float fa5, float fa6, float fa7,
		FloatEmpty8Float a1_a2, int a3, float a4);

	[MethodImpl(MethodImplOptions.NoInlining)]
	public static FloatEmpty8Float Echo_FloatEmpty8Float_InIntegerRegs_RiscV_Managed(
		int a0,
		float fa0, float fa1, float fa2, float fa3, float fa4, float fa5, float fa6, float fa7,
		FloatEmpty8Float a1_a2, int a3, float a4)
	{
		a1_a2.Float0 += (float)a3 + a4;
		return a1_a2;
	}

	[Fact]
	public static void Test_FloatEmpty8Float_InIntegerRegs_RiscV()
	{
		FloatEmpty8Float expected = FloatEmpty8Float.Get();
		FloatEmpty8Float native = Echo_FloatEmpty8Float_InIntegerRegs_RiscV(
			0, 0f, 1f, 2f, 3f, 4f, 5f, 6f, 7f, expected, 1, -1f);
		FloatEmpty8Float managed = Echo_FloatEmpty8Float_InIntegerRegs_RiscV_Managed(
			0, 0f, 1f, 2f, 3f, 4f, 5f, 6f, 7f, expected, 1, -1f);

		Assert.Equal(expected, native);
		Assert.Equal(expected, managed);
	}

	[Fact]
	public static void Test_FloatEmpty8Float_InIntegerRegs_ByReflection_RiscV()
	{
		var expected = FloatEmpty8Float.Get();
		var native = (FloatEmpty8Float)typeof(Program).GetMethod("Echo_FloatEmpty8Float_InIntegerRegs_RiscV").Invoke(
			null, new object[] {0, 0f, 1f, 2f, 3f, 4f, 5f, 6f, 7f, expected, 1, -1f});
		var managed = (FloatEmpty8Float)typeof(Program).GetMethod("Echo_FloatEmpty8Float_InIntegerRegs_RiscV_Managed").Invoke(
			null, new object[] {0, 0f, 1f, 2f, 3f, 4f, 5f, 6f, 7f, expected, 1, -1f});

		Assert.Equal(expected, native);
		Assert.Equal(expected, managed);
	}

	[DllImport("EmptyStructsLib")]
	public static extern FloatEmpty8Float Echo_FloatEmpty8Float_Split_RiscV(
		int a0, int a1, int a2, int a3, int a4, int a5, int a6,
		float fa0, float fa1, float fa2, float fa3, float fa4, float fa5, float fa6, float fa7,
		FloatEmpty8Float a7_stack0, int stack1, float stack2);

	[MethodImpl(MethodImplOptions.NoInlining)]
	public static FloatEmpty8Float Echo_FloatEmpty8Float_Split_RiscV_Managed(
		int a0, int a1, int a2, int a3, int a4, int a5, int a6,
		float fa0, float fa1, float fa2, float fa3, float fa4, float fa5, float fa6, float fa


back(HapticFeedbackConstants.SEGMENT_FREQUENT_TICK)
                        }

                    ReorderHapticFeedbackType.END ->
                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
                            view.performHapticFeedback(HapticFeedbackConstants.GESTURE_END)
                        }
                }
            }
        }
    }
}

private enum class ReorderHapticFeedbackType {
    START,
    MOVE,
    END,
}

private interface ReorderHapticFeedback {
    fun performHapticFeedback(type: ReorderHapticFeedbackType)
}
package net.primal.android.theme.colors

import androidx.compose.material3.lightColorScheme
import androidx.compose.ui.graphics.Color

private val iceBrandText = Color(0xFF444444)
private val iceBackground1 = Color(0xFFF5F5F5)
private val iceBackground2 = Color(0xFFFFFFFF)
private val iceBackground3 = Color(0xFFE5E5E5)
private val iceBackground4 = Color(0xFFF5F5F5)
private val iceBackground5 = Color(0xFFEEEEEE)
private val iceForeground1 = Color(0xFF111111)
private val iceForeground2 = Color(0xFF111111)
private val iceForeground3 = Color(0xFF666666)
private val iceForeground4 = Color(0xFF808080)
private val iceForeground5 = Color(0xFF808080)
private val iceForeground6 = Color(0xFFC8C8C8)
private val iceAccent0 = Color(0xFF2394EF)
private val iceAccent1 = Color(0xFF2394EF)
private val iceAccent2 = Color(0xFF0C7DD8)
private val iceSuccessBright = Color(0xFF52CE0A)
private val iceSuccessDim = Color(0xFFC4F49F)
private val iceWarningBright = Color(0xFFC40000)
private val iceWarningDim = Color(0xFFFAC3C3)
private val iceReplied = Color(0xFF444444)
private val iceZapped = Color(0xFFFFA02F)
private val iceLiked = Color(0xFFCA079F)
private val iceReposted = Color(0xFF52CE0A)
private val iceBookmarked = Color(0xFF0090F8)

val iceColorScheme = lightColorScheme(
    primary = iceAccent0,
    onPrimary = iceForeground1,
    secondary = iceAccent1,
    onSecondary = iceForeground1,
    tertiary = iceAccent2,
    onTertiary = iceForeground1,
    background = iceBackground1,
    onBackground = iceForeground1,
    surface = iceBackground1,
    onSurface = iceForeground1,
    surfaceVariant = iceBackground2,
    onSurfaceVariant = iceForeground1,
    error = iceWarningBright,
    outline = iceForeground6,
)

val iceExtraColorScheme = extraColorScheme(
    onBrand = iceBrandText,
    surfaceVariantAlt1 = iceBackground3,
    surfaceVariantAlt2 = iceBackground4,
    surfaceVariantAlt3 = iceBackground5,
    onSurfaceVariantAlt1 = iceForeground2,
    onSurfaceVariantAlt2 = iceForeground3,
    onSurfaceVariantAlt3 = iceForeground4,
    onSurfaceVariantAlt4 = iceForeground5,
    warning = iceWarningDim,
    successBright = iceSuccessBright,
    successDim = iceSuccessDim,
    replied = iceReplied,
    zapped = iceZapped,
    liked = iceLiked,
    reposted = iceReposted,
    bookmarked = iceBookmarked,
)
package net.primal.android.theme.domain

import androidx.compose.material3.ColorScheme
import net.primal.android.theme.colors.ExtraColorScheme
import net.primal.android.theme.colors.iceColorScheme
import net.primal.android.theme.colors.iceExtraColorScheme
import net.primal.android.theme.colors.midnightColorScheme
import net.primal.android.theme.colors.midnightExtraColorScheme
import net.primal.android.theme.colors.sunriseColorScheme
import net.primal.android.theme.colors.sunriseExtraColorScheme
import net.primal.android.theme.colo


  font-weight: 700;
  line-height: 24px;
}

.tag-item.secondary {
  background-color: #615dfa;
  transition: background-color .2s ease-in-out;
}

.tag-item.secondary:hover {
  color: #fff;
  background-color: #23d2e2;
}

/*-----------------------------
    17. XM TOOLTIP TEXT
-----------------------------*/
.xm-tooltip-text {
  padding: 0 12px;
  border-radius: 200px;
  background-color: #3e3f5e;
  color: #fff;
  font-size: 0.75rem;
  font-weight: 700;
  line-height: 24px;
}

/*--------------------------------
    18. USER SHORT DESCRIPTION
--------------------------------*/
.user-short-description {
  padding-top: 84px;
  position: relative;
}

.user-short-description.big {
  padding-top: 52px;
}

.user-short-description.big .user-short-description-avatar {
  top: -116px;
  margin-left: -74px;
}

.user-short-description.big .user-short-description-title {
  font-size: 1.5rem;
}

.user-short-description.big .user-short-description-text {
  font-size: 0.75rem;
}

.user-short-description.small {
  padding-top: 62px;
}

.user-short-description.small .user-short-description-avatar {
  margin-left: -50px;
}

.user-short-description.landscape {
  padding: 0 0 0 32px;
}

.user-short-description.landscape .user-short-description-avatar {
  top: 0;
  margin-left: 0;
}

.user-short-description.landscape .user-short-description-title,
.user-short-description.landscape .user-short-description-text {
  text-align: left;
}

.user-short-description.landscape.tiny {
  height: 56px;
  padding-top: 12px;
}

.user-short-description.landscape.tiny .user-short-description-avatar {
  left: -25px;
}

.user-short-description .user-short-description-avatar {
  position: absolute;
  top: -54px;
  left: 50%;
  margin-left: -60px;
}

.user-short-description .user-short-description-title,
.user-short-description .user-short-description-text {
  font-weight: 700;
  text-align: center;
}

.user-short-description .user-short-description-title {
  font-size: 1.125rem;
}

.user-short-description .user-short-description-title a {
  color: #3e3f5e;
  font-weight: 700;
}

.user-short-description .user-short-description-title.small {
  font-size: 0.875rem;
}

.user-short-description .user-short-description-text {
  margin-top: 10px;
  color: #adafca;
  font-size: 0.6875rem;
  font-weight: 700;
  text-transform: uppercase;
}

.user-short-description .user-short-description-text a {
  color: #adafca;
  font-weight: 700;
}

.user-short-description .user-short-description-text a:hover {
  color: #00c7d9;
}

.user-short-description .user-short-description-text.regular {
  font-size: 0.75rem;
  font-weight: 500;
  text-transform: none;
}


om_phy_qmp_v3_phy_ops = {
	.init		= ufs_qcom_phy_qmp_v3_init,
	.exit		= ufs_qcom_phy_qmp_v3_exit,
	.power_on	= ufs_qcom_phy_power_on,
	.power_off	= ufs_qcom_phy_power_off,
	.owner		= THIS_MODULE,
};

struct ufs_qcom_phy_specific_ops phy_v3_ops = {
	.calibrate_phy		= ufs_qcom_phy_qmp_v3_phy_calibrate,
	.start_serdes		= ufs_qcom_phy_qmp_v3_start_serdes,
	.is_physical_coding_sublayer_ready = ufs_qcom_phy_qmp_v3_is_pcs_ready,
	.set_tx_lane_enable	= ufs_qcom_phy_qmp_v3_set_tx_lane_enable,
	.ctrl_rx_linecfg	= ufs_qcom_phy_qmp_v3_ctrl_rx_linecfg,
	.power_control		= ufs_qcom_phy_qmp_v3_power_control,
	.dbg_register_dump	= ufs_qcom_phy_qmp_v3_dbg_register_dump,
};

static int ufs_qcom_phy_qmp_v3_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct phy *generic_phy;
	struct ufs_qcom_phy_qmp_v3 *phy;
	int err = 0;

	phy = devm_kzalloc(dev, sizeof(*phy), GFP_KERNEL);
	if (!phy) {
		err = -ENOMEM;
		goto out;
	}

	generic_phy = ufs_qcom_phy_generic_probe(pdev, &phy->common_cfg,
				&ufs_qcom_phy_qmp_v3_phy_ops, &phy_v3_ops);

	if (!generic_phy) {
		dev_err(dev, "%s: ufs_qcom_phy_generic_probe() failed\n",
			__func__);
		err = -EIO;
		goto out;
	}

	phy_set_drvdata(generic_phy, phy);

	strlcpy(phy->common_cfg.name, UFS_PHY_NAME,
		sizeof(phy->common_cfg.name));

out:
	return err;
}

static const struct of_device_id ufs_qcom_phy_qmp_v3_of_match[] = {
	{.compatible = "qcom,ufs-phy-qmp-v3"},
	{},
};
MODULE_DEVICE_TABLE(of, ufs_qcom_phy_qmp_v3_of_match);

static struct platform_driver ufs_qcom_phy_qmp_v3_driver = {
	.probe = ufs_qcom_phy_qmp_v3_probe,
	.driver = {
		.of_match_table = ufs_qcom_phy_qmp_v3_of_match,
		.name = "ufs_qcom_phy_qmp_v3",
	},
};

module_platform_driver(ufs_qcom_phy_qmp_v3_driver);

MODULE_DESCRIPTION("Universal Flash Storage (UFS) QCOM PHY QMP v3");
MODULE_LICENSE("GPL v2");


14285714286rem + 0.35714285714285715vw,
    1.5rem
  );
  line-height: 1.563rem; /* 25px */
  line-height: clamp(
    1.563rem,
    1.4915714285714285rem + 0.35714285714285715vw,
    1.813rem
  );
}

.heading4 {
  font-family: var(--ibm-plex-sans);
  font-weight: var(--semi-bold);
  font-size: 1.125rem; /* 18px */
  font-size: clamp(
    1.125rem,
    1.0892857142857142rem + 0.17857142857142858vw,
    1.25rem
  );
  line-height: 1.375rem; /* 22px */
  line-height: clamp(
    1.375rem,
    1.3212857142857144rem + 0.26857142857142846vw,
    1.563rem
  );
}

.subheading1 {
  font-family: var(--inter);
  font-weight: var(--normal);
  font-size: 1.5rem; /* 24px */
  font-size: clamp(
    1.5rem,
    1.4285714285714286rem + 0.35714285714285715vw,
    1.75rem
  );
  line-height: 1.875rem; /* 30px */
  line-height: clamp(
    1.875rem,
    1.8035714285714286rem + 0.35714285714285715vw,
    2.125rem
  );
}

.subheading2 {
  font-family: var(--inter);
  font-weight: var(--normal);
  font-size: 1.25rem; /* 20px */
  font-size: clamp(
    1.25rem,
    1.1785714285714286rem + 0.35714285714285715vw,
    1.5rem
  );
  line-height: 1.563rem; /* 25px */
  line-height: clamp(
    1.563rem,
    1.4738571428571428rem + 0.44571428571428573vw,
    1.875rem
  );
}

.paragraph1 {
  font-family: var(--inter);
  font-weight: var(--normal);
  font-size: 1rem; /* 16px */
  font-size: clamp(
    1rem,
    0.9642857142857143rem + 0.17857142857142858vw,
    1.125rem
  );
  line-height: 1.375rem; /* 22px */
  line-height: clamp(
    1.375rem,
    1.3035714285714286rem + 0.35714285714285715vw,
    1.625rem
  );
}

.paragraph2 {
  font-family: var(--inter);
  font-weight: var(--normal);
  font-size: 0.875rem; /* 14px */
  font-size: clamp(
    0.875rem,
    0.8392857142857143rem + 0.17857142857142858vw,
    1rem
  );
  line-height: 1.125rem; /* 18px */
  line-height: clamp(
    1.125rem,
    1.0535714285714286rem + 0.35714285714285715vw,
    1.375rem
  );
}

.paragraph3 {
  font-family: var(--inter);
  font-weight: var(--normal);
  font-size: 0.75rem; /* 12px */
  font-size: clamp(
    0.75rem,
    0.7142857142857143rem + 0.17857142857142858vw,
    0.875rem
  );
  line


         playhead += otio_clip.source_range.duration.value

                # Process nested sequence
                build_sequence(
                    otio_clip,
                    project=project,
                    track_kind=otio_track.kind
                )

            elif isinstance(otio_clip, otio.schema.Clip):
                # Create a Clip
                clip = create_clip(otio_clip, tagsbin, sequencebin)

                # Create TrackItem
                trackitem = create_trackitem(
                    playhead,
                    track,
                    otio_clip,
                    clip
                )

                # Add markers
                add_markers(otio_clip, trackitem, tagsbin)

                # Add trackitem to track
                track.addTrackItem(trackitem)

                # Update playhead
                playhead = trackitem.timelineOut() + 1

            elif isinstance(otio_clip, otio.schema.Transition):
                # Store transitions for when all clips in the track are created
                _transitions.append((otio_track, otio_clip))

            elif isinstance(otio_clip, otio.schema.Gap):
                # Hiero has no fillers, slugs or blanks at the moment
                playhead += otio_clip.source_range.duration.value

        # Apply transitions we stored earlier now that all clips are present
        warnings = []
        for otio_track, otio_item in _transitions:
            # Catch warnings form transitions in case
            # of unsupported transitions
            warning = apply_transition(otio_track, otio_item, track)
            if warning:
                warnings.append(warning)

        if warnings:
            inform(warnings)


_e855b3fd36793c52e83cf12e5f07a065 = L.circleMarker(
                [50.102, -122.936],
                {"bubblingMouseEvents": true, "color": "#e6194b", "dashArray": null, "dashOffset": null, "fill": true, "fillColor": "#e6194b", "fillOpacity": 0.2, "fillRule": "evenodd", "lineCap": "round", "lineJoin": "round", "opacity": 1.0, "radius": 5, "stroke": true, "weight": 3}
            ).addTo(map_c85de8a8e8f13113fd47a905205f0f7e);

        var popup_816956520c0fba2b81a533061f95ad89 = L.popup({"maxWidth": "100%"});

                var html_ea4f1f452dd11979844cd80bad854854 = $(`<div id="html_ea4f1f452dd11979844cd80bad854854" style="width: 100.0%; height: 100.0%;">0</div>`)[0];
                popup_816956520c0fba2b81a533061f95ad89.setContent(html_ea4f1f452dd11979844cd80bad854854);

        circle_marker_e855b3fd36793c52e83cf12e5f07a065.bindPopup(popup_816956520c0fba2b81a533061f95ad89)
        ;

            var circle_marker_34c7334d195734249f2e84b7ad7d81bb = L.circleMarker(
                [49.278, -122.918],
                {"bubblingMouseEvents": true, "color": "#e6194b", "dashArray": null, "dashOffset": null, "fill": true, "fillColor": "#e6194b", "fillOpacity": 0.2, "fillRule": "evenodd", "lineCap": "round", "lineJoin": "round", "opacity": 1.0, "radius": 5, "stroke": true, "weight": 3}
            ).addTo(map_c85de8a8e8f13113fd47a905205f0f7e);

        var popup_9ebd7cfde0462e469a34f1387f8e37d6 = L.popup({"maxWidth": "100%"});

                var html_ff0b078096a1b82aad5a18bfb5945d43 = $(`<div id="html_ff0b078096a1b82aad5a18bfb5945d43" style="width: 100.0%; height: 100.0%;">0</div>`)[0];
                popup_9ebd7cfde0462e469a34f1387f8e37d6.setContent(html_ff0b078096a1b82aad5a18bfb5945d43);

        circle_marker_34c7334d195734249f2e84b7ad7d81bb.bindPopup(popup_9ebd7cfde0462e469a34f1387f8e37d6)
        ;

            var circle_marker_8af4ca35cdcad54b64817c39a3fa29bf = L.circleMarker(
                [50.144, -123.111],
                {"bubblingMouseEvents": true, "color": "#e6194b", "dashArray": null, "dashOffset": null, "fill": true, "fillColor": "#e6194b", "fillOpacity": 0.2, "fillRule": "evenodd", "lineCap": "round", "lineJoin": "round", "opacity": 1.0, "radius": 5, "stroke": true, "weight": 3}
            ).addTo(map_c85de8a8e8f13113fd47a905205f0f7e);


.461938155074057e+00},
	{"XFT", -2.338404085110848e+01, -6.442873398075137e+00},
	{"XFU", -2.342533528439170e+01, -6.484167831358351e+00},
	{"XFV", -2.937712758799703e+01, -1.243596013496368e+01},
	{"XFW", -2.712944251259569e+01, -1.018827505956235e+01},
	{"XFX", -3.465451679902609e+01, -1.771334934599274e+01},
	{"XFY", -2.777197485680206e+01, -1.083080740376871e+01},
	{"XFZ", -3.078311025855262e+01, -1.384194280551927e+01},
	{"XGA", -2.181483448290722e+01, -3.574602489758117e+00},
	{"XGB", -2.735622227830990e+01, -9.115990285160791e+00},
	{"XGC", -2.760724883831932e+01, -9.367016845170214e+00},
	{"XGD", -2.747835389177840e+01, -9.238121898629293e+00},
	{"XGE", -2.040778276857789e+01, -2.167550775428782e+00},
	{"XGF", -2.716193266702108e+01, -8.921700673871976e+00},
	{"XGG", -2.730342280705927e+01, -9.063190813910172e+00},
	{"XGH", -2.382588725882494e+01, -5.585655265675833e+00},
	{"XGI", -2.239109383162563e+01, -4.150861838476525e+00},
	{"XGJ", -3.083127341500279e+01, -1.259104142185369e+01},
	{"XGK", -3.106958734830004e+01, -1.282935535515093e+01},
	{"XGL", -2.203015766447591e+01, -3.789925671326806e+00},
	{"XGM", -2.711371768262325e+01, -8.873485689474148e+00},
	{"XGN", -2.622654944000659e+01, -7.986317446857486e+00},
	{"XGO", -2.120134862620923e+01, -2.961116633060123e+00},
	{"XGP", -2.759950983952505e+01, -9.359277846375939e+00},
	{"XGQ", -3.236266644291810e+01, -1.412243444976899e+01},
	{"XGR", -1.996858699668428e+01, -1.728355003535175e+00},
	{"XGS", -2.543948660947519e+01, -7.199254616326083e+00},
	{"XGT", -2.455219882495509e+01, -6.311966831805979e+00},
	{"XGU", -2.201455761095603e+01, -3.774325617806928e+00},
	{"XGV", -3.020310822483859e+01, -1.196287623168948e+01},
	{"XGW", -2.678425185281058e+01, -8.544019859661478e+00},
	{"


s(2);
  @$pb.TagNumber(3)
  void clearAmount() => clearField(3);
}

class DirectiveUndelegate extends $pb.GeneratedMessage {
  static final $pb.BuilderInfo _i = $pb.BuilderInfo(const $core.bool.fromEnvironment('protobuf.omit_message_names') ? '' : 'DirectiveUndelegate', package: const $pb.PackageName(const $core.bool.fromEnvironment('protobuf.omit_message_names') ? '' : 'TW.Harmony.Proto'), createEmptyInstance: create)
    ..aOS(1, const $core.bool.fromEnvironment('protobuf.omit_field_names') ? '' : 'delegatorAddress')
    ..aOS(2, const $core.bool.fromEnvironment('protobuf.omit_field_names') ? '' : 'validatorAddress')
    ..a<$core.List<$core.int>>(3, const $core.bool.fromEnvironment('protobuf.omit_field_names') ? '' : 'amount', $pb.PbFieldType.OY)
    ..hasRequiredFields = false
  ;

  DirectiveUndelegate._() : super();
  factory DirectiveUndelegate({
    $core.String? delegatorAddress,
    $core.String? validatorAddress,
    $core.List<$core.int>? amount,
  }) {
    final _result = create();
    if (delegatorAddress != null) {
      _result.delegatorAddress = delegatorAddress;
    }
    if (validatorAddress != null) {
      _result.validatorAddress = validatorAddress;
    }
    if (amount != null) {
      _result.amount = amount;
    }
    return _result;
  }
  factory DirectiveUndelegate.fromBuffer($core.List<$core.int> i, [$pb.ExtensionRegistry r = $pb.ExtensionRegistry.EMPTY]) => create()..mergeFromBuffer(i, r);
  factory DirectiveUndelegate.fromJson($core.String i, [$pb.ExtensionRegistry r = $pb.ExtensionRegistry.EMPTY]) => create()..mergeFromJson(i, r);
  @$core.Deprecated(
  'Using this can add significant overhead to your binary. '
  'Use [GeneratedMessageGenericExtensions.deepCopy] instead. '
  'Will be removed in next major version')
  DirectiveUndelegate clone() => DirectiveUndelegate()..mergeFromMessage(this);
  @$core.Deprecated(
  'Using this can add significant overhead to your binary. '
  'Use [GeneratedMessageGenericExtensions.rebuild] instead. '
  'Will be removed in next major version')
  DirectiveUndelegate copyWith(void Function(DirectiveUndelegate) updates) => super.copyWith((message) => updates(message as DirectiveUndelegate)) as DirectiveUndelegate; // ignore: deprecated_member_use
  $pb.BuilderInfo get info_ => _i;
  @$core.pragma('dart2js:noInline')
  static DirectiveUndelegate create() => DirectiveUndelegate._();
  DirectiveUndelegate createEmptyInstance() => create();
  static $pb.PbList<DirectiveUndelegate> createRepeated() => $pb.PbList<DirectiveUndelegate>();
  @$core.pragma('dart2js:noInline')
  static DirectiveUndelegate getDefault() => _defaultInstance ??= $pb.GeneratedMessage.$_defaultFor<DirectiveUndelegate>(create);
  static DirectiveUndelegate? _defaultInstance;

  @$pb.TagNumber(1)
  $core.String get delegatorAddress => $_getSZ(0);
  @$pb.TagNumber(1)
  set delegatorAddress($core.String v) { $_setString(0, v); }
  @$pb.TagNumber(1)
  $core.bool hasDelegatorAddress() => $_has(0);
  @$pb.TagNumber(1)
  void clearDelegatorAddress() => clearField(1);

  @$pb.TagNumber(2)
  $core.String get validatorAddress => $_getSZ(1);
  @$pb.TagNumber(2)


/// @file
/// @brief Declares the MeshCache class used to store renderer-specific cache data for a Mesh.

#ifndef A3DMESHCACHE_H
#define A3DMESHCACHE_H

#include "common.h"
#include <QObject>

namespace A3D {

class Mesh;

/// @brief Base class for storing and managing cached data derived from a Mesh.
class MeshCache : public QObject {
	Q_OBJECT
public:
	/// @brief Constructs a MeshCache.
	/// @param[in] parent The parent Mesh associated with this cache.
	explicit MeshCache(Mesh* parent);

	/// @brief Destructor.
	~MeshCache();

	/// @brief Gets the parent Mesh associated with this cache.
	/// @return Pointer to the parent Mesh.
	Mesh* mesh() const;

	/// @brief Marks the cache as dirty, indicating that it needs to be regenerated or updated.
	void markDirty();

	/// @brief Checks whether the cache is marked as dirty.
	/// @return True if the cache is dirty; false otherwise.
	bool isDirty() const;

protected:
	/// @brief Marks the cache as clean, indicating that it is up-to-date.
	void markClean();

private:
	QPointer<Mesh> m_mesh; ///< Weak pointer to the associated Mesh.
	bool m_isDirty;        ///< Flag indicating whether the cache is dirty.
};

}

#endif // A3DMESHCACHE_H


0
{

}

[SchemaStruct(TigerStrategy.DESTINY1_RISE_OF_IRON, "BD068080", 0x100)]
[SchemaStruct(TigerStrategy.DESTINY2_SHADOWKEEP_2601, "45858080", 0x100)]
[SchemaStruct(TigerStrategy.DESTINY2_BEYONDLIGHT_3402, "DD818080", 0x100)]
public struct D2Class_DD818080
{
    public ResourceInTagPointer Unk00;
    [SchemaField(0x30)]
    public DynamicArray<D2Class_DC818080> Unk30;
    public DynamicArray<D2Class_40868080> Unk40;
}

[SchemaStruct(TigerStrategy.DESTINY1_RISE_OF_IRON, "98058080", 0x10)]
[SchemaStruct(TigerStrategy.DESTINY2_SHADOWKEEP_2601, "DC818080", 0x40)]
public struct D2Class_DC818080
{
    //public ResourceInTagPointer Unk00;
    //public ResourcePointer Unk10;
    [SchemaField(0x0, TigerStrategy.DESTINY1_RISE_OF_IRON)]
    [SchemaField(0x20, TigerStrategy.DESTINY2_SHADOWKEEP_2601)]
    public DynamicArray<D2Class_4F9F8080> Unk20;
}

[SchemaStruct(TigerStrategy.DESTINY1_RISE_OF_IRON, "B0018080", 0x20)]
[SchemaStruct(TigerStrategy.DESTINY2_SHADOWKEEP_2601, "759F8080", 0x20)]
[SchemaStruct(TigerStrategy.DESTINY2_BEYONDLIGHT_3402, "4F9F8080", 0x20)]
public struct D2Class_4F9F8080
{
    public Tiger.Schema.Vector4 Rotation;
    public Tiger.Schema.Vector4 Translation;
}

[SchemaStruct("40868080", 8)]
public struct D2Class_40868080
{
    public ushort Unk00;
    public ushort Unk02;
    public uint Unk04;
}

[SchemaStruct(TigerStrategy.DESTINY1_RISE_OF_IRON, "9A048080", 0xE0)]
[SchemaStruct(TigerStrategy.DESTINY2_SHADOWKEEP_2601, "46858080", 0xF0)]
[SchemaStruct(TigerStrategy.DESTINY2_BEYONDLIGHT_3402, "DE818080", 0x108)]
public struct D2Class_DE818080
{
    //public ResourceInTagPointer Unk00;
    //[SchemaField(0x48)]
    //public ResourcePointer Unk48;
    //public Tag Unk50;  // 239B8080 WQ, 549C8080 SK
    //[SchemaField(0x60, TigerStrategy.DESTINY2_SHADOWKEEP_2601)]
    //[SchemaField(0x68, TigerStrategy.DESTINY2_BEYONDLIGHT_3402)]
    //public ResourcePointer Unk68;
    //public Tag Unk70;  // 239B8080 WQ, 549C8080 SK
    [SchemaField(0x70, TigerStrategy.DESTINY1_RISE_OF_IRON)]
    [SchemaField(0x78, TigerStrategy.DESTINY2_SHADOWKEEP_2601)]
    [SchemaField(0x88, TigerStrategy.DESTINY2_BEYONDLIGHT_3402)]
    public TigerHash Unk88;
    public TigerHash Unk8C;  // this is actually zeros in SK
    [SchemaField(0x88, TigerStrategy.DESTINY1_RISE_OF_IRON)]
    [SchemaField(0x80, TigerStrategy.DESTINY2_SHADOWKEEP_2601)]
    [SchemaField(0x90, TigerStrategy.DESTINY2_BE


。猫三联的价格在50元到100元之间。

猫咪疫苗有哪些种类?

1、猫三联疫苗：包括猫瘟热、猫传染性肝炎和猫鼻气管炎。 猫四联疫苗：除了猫三联疫苗的三种疫苗外，还包含猫钩端螺旋体病毒。 狂犬疫苗：防止猫被狂犬病病毒感染。猫咪在接种疫苗之前，需要进行身体检查。

2、猫的核心疫苗：毛细小病毒，猫疱疹病毒-1型，猫杯状病毒，狂犬病毒疫苗是猫咪需要接种的核心疫苗，其中前三种疫苗的联合疫苗就是大家最常见的猫三联苗。

3、猫咪需要打预防传染病疫苗和狂犬病，预防传染病疫苗主要是预防猫瘟病毒、猫疱疹病毒、猫杯状病毒这三种常见猫咪的传染病。狂犬病疫苗主要预防猫咪和人类患狂犬病。

4、猫疫苗的常见类型 猫三联疫苗：猫三联主要针对猫瘟、猫鼻支和猫杯状病毒，猫咪在达到2月龄时就可以首次接种，连续注射两次，每次间隔2-3周，首次免疫后一年加强一次，之后每三年加强一次。

5、猫疫苗的种类很多，每种疫苗都是为了防范不同的疾病而设计的。主要有哪些猫疫苗常见的猫疫苗包括：猫三联疫苗、猫四联疫苗、猫五联疫苗、猫白血病疫苗、猫狂犬疫苗、猫传染性腹膜炎疫苗、猫鼻气管炎疫苗等。

6、猫咪应该接种哪些疫苗一般来说，猫咪需要接种的疫苗包括三联疫苗、四联疫苗和狂犬疫苗。三联疫苗包括对猫瘟、猫流感和弓形体病毒的防范。这些病都能严重影响到猫咪的身体<a href="http://www.to3158.cn/tags-j-k65af29e397654.html" target="_


om_pretrained(base_model, **kwargs)
        return OmniGenomeModel(config, base_model, tokenizer, *args, **kwargs)

    def model_info(self):
        info = f"Model Name: {self.__class__.__name__}\n"
        info += f"Model Metadata: {self.metadata}\n"
        info += f"Base Model Name: {self.config.name_or_path}\n"
        info += f"Model Type: {self.config.model_type}\n"
        info += f"Model Architecture: {self.config.architectures}\n"
        info += f"Model Parameters: {count_parameters(self.model) / 1e6} M\n"
        info += f"Model Config: {self.config}\n"
        fprint(info)
        return info


ll_pos[1] + layer.offset[1] + layer.vel[1] * counter,
								scene.layerall_pos[2] + layer.offset[2] + layer.vel[2] * counter,
								layer.spacing[1],
								layer.spacing[2],
								main.font_def[layer.font[1] .. layer.font[7]],
								layer.textdelay,
								main.f_lineLength(
									scene.layerall_pos[1] + layer.offset[1] + layer.vel[1] * counter,
									t.info.localcoord[1],
									layer.font[3],
									layer.textwindow,
									true
								)
							)
						end
					end
				end
				--draw layerno = 1 backgrounds
				if scene.bg_name ~= '' then
					bgDraw(scene.bg, 1)
				end
				--draw fadein / fadeout
				if i == scene.end_time - scene.fadeout_time then
					fadeType = 'fadeout'
					fadeStart = getFrameCount()
				end
				main.fadeActive = fadeColor(
					fadeType,
					fadeStart,
					scene[fadeType .. '_time'],
					scene[fadeType .. '_col'][1],
					scene[fadeType .. '_col'][2],
					scene[fadeType .. '_col'][3]
				)
				main.f_cmdInput()
				refresh()
			end
		end
	end
end

local function f_parse(path)
	local content = loadText(path)
	if content == nil then
		return nil
	end
	local fileDir, fileName = path:match('^(.-)([^/\\]+)$')
	local t = {info = {localcoord = {320, 240}}}
	local pos = t
	local pos_default = {}
	local pos_val = {}
	t.sceneOrder = {}
	t.anim = {}
	t.scene = {}
	t.def = fileDir .. fileName
	t.fileDir = fileDir
	t.fileName = fileName
	local tmp = ''
	local t_default =
	{
		scenedef = {
			spr = '',
			snd = '',
			font = {},
			font_height = {},
			startscene = 0,
			skipbutton = 1, --Ikemen feature
		},
		scene = {},
	}
	for line in content:gmatch("([^\r\n]*)[\r\n]?") do
		line = line:gsub('%s*;.*$', '')
		if line:match('^%s*%[.-%s*%]%s*$') then --matched [] group
			line = line:match('^%s*%[(.-)%s*%]%s*$') --match text between []
			line = line:gsub('[%. ]', '_') --change . and space to _
			local row = tostring(line:lower())
			if row:match('^scene$') or row:match('^scene_') then --matched scene
				if not t.scene[row] then --mugen skips duplicated scenes
					table.insert(t.sceneOrder, row)
					t.scene[row] = {}
					pos = t.scene[row]
					pos.layer = {}
					pos.sound = {}
					t_default.scene[row] =
					{
						end_time = 0,
						fadein_time = 0,
						fadein_col = {0, 0, 0},
						fadeout_time = 0,
						fadeout_col = {0, 0, 0},
						clearcolor = {},
						layerall_pos = {},
						layer = {},
						sound = {},
						bgm = '',
						bgm_loop = 0,
						bgm_volume = 100,  --Ikemen feature
						bgm_loopstart = 0, --Ikemen feature
						bgm_loopend = 0, --Ikemen feature
						bg_name = ''
					}
					pos_default = t_default.scene[row]
				end
			elseif row:match('^begin_action_[0-9]+$') then --matched anim
				row = tonumber(row:match('^begin_action_([0-9]+)$'))


("FILE")
          .short("f")
          .long("input-file")
          .takes_value(true)
          .required(true)
          .help("The gene count input file with genes as rows and samples as columns")
      )
      .arg(
        clap::Arg::with_name("output-file")
          .value_name("OUTFILE")
          .short("o")
          .long("output-file")
          .takes_value(true)
          .required(true)
          .help("The pairwise MI output")
      )
      .arg(
        clap::Arg::with_name("index-file")
          .value_name("INDEXFILE")
          .short("x")
          .long("index-file")
          .takes_value(true)
          .required(false)
          .help("Index file")
      )
      .arg(
        clap::Arg::with_name("index")
          .value_name("INDEX")
          .short("i")
          .long("index")
          .takes_value(false)
          .required(false)
          .help("Build index")
      )
      .arg(
        clap::Arg::with_name("verbose")
          .value_name("VERBOSE")
          .short("v")
          .long("verbose")
          .takes_value(false)
          .required(false)
          .help("Activate additional output")
      )
      .arg(
        clap::Arg::with_name("k-mer")
          .value_name("KMER")
          .short("k")
          .long("kmer")
          .takes_value(true)
          .required(false)
          .help("Length of k-mer sequences, defaults to 22")
      )
      .arg(
        clap::Arg::with_name("thread-number")
          .value_name("THREADS")
          .short("t")
          .long("thread-number")
          .takes_value(true)
          .required(false)
          .help("Number of parallel threads, defaults to 4")
      )
      .get_matches()
}use crate::PhysAddr;
use crate::permission::Permission;
use super::asm::*;

#[allow(non_camel_case_types)]
pub enum MairFlag {
    Normal = 0xff,
    NormalNC = 0x44,
    DevicenGnRnE = 0x00,
    DevicenGnRE = 0x04,
    DeviceGRE = 0x0c,
}

#[allow(non_camel_case_types)]
#[derive(Copy, Clone, Debug)]
pub enum MemoryAttr {
    Normal = 0,
    NormalNC = 1,
    DevicenGnRnE = 2,
    DevicenGnRE = 3,
    DeviceGRE = 4,
}

const AP_OFFSET: usize = 6;
#[derive(Copy, Clone, Debug)]
pub enum AccessPermission {
    KernelOnly = 0b00 << AP_OFFSET,
    ReadWrite = 0b01 << AP_OFFSET,
    KernelRead = 0b10 << AP_OFFSET,
    ReadOnly = 0b11 << AP_OFFSET,
}

impl Into<AccessPermission> for Permission {
    fn into(self) -> AccessPermission {
        if self.contains(Permission::READABLE & Permission::WRITABLE) {
            AccessPermission::ReadWrite
        } else if self.contains(Permission::READABLE) {
            AccessPermission::ReadOnly
        } else {
            AccessPermission::KernelOnly
        }
    }
}

const SH_OFFSET: usize = 8;
#[derive(Copy, Clone, Debug)]
pub enum Shareability {
    NonSharable = 0b00 << SH_OFFSET,
    Unpredictable = 0b01 << SH_OFFSET,
    OuterSharable = 0b10 << SH_OFFSET,
    InnerSharable = 0b11 << SH_OFFSET,
}


-enriching-editor-contextual-information-navigation/) (JetBrains)
* [Unit testing receives major updates in ReSharper and Rider 2018.3 EAP](https://blog.jetbrains.com/dotnet/2018/12/12/unit-testing-receives-major-updates-resharper-rider-2018-3-eap/) (JetBrains)
* [.editorconfig updates, more build options, better Roslyn support in Rider 2018.3 EAP](https://blog.jetbrains.com/dotnet/2018/12/13/editorconfig-updates-build-options-better-roslyn-support-rider-2018-3-eap/) (JetBrains)
* [Keeping Track of Issues and Tasks in Rider](https://blog.jetbrains.com/dotnet/2019/02/12/keeping-track-issues-tasks-rider/) (JetBrains)
* [Writing plugins for ReSharper and Rider](https://blog.jetbrains.com/dotnet/2019/02/14/writing-plugins-resharper-rider/) (JetBrains)
* [Connecting to a Microsoft SQL Server Linux Docker Container from Rider](https://blog.jetbrains.com/dotnet/2019/03/05/connecting-microsoft-sql-server-linux-docker-container-rider/) (JetBrains)
* [Profiling Mono and Mono Unity Apps on Windows, macOS, and Linux](https://blog.jetbrains.com/dotnet/2019/04/03/profiling-mono-mono-unity-apps-windows-macos-linux/) (JetBrains)
* [Code Coverage on macOS and Linux in Rider 2019.1](https://blog.jetbrains.com/dotnet/2019/04/10/code-coverage-macos-linux-rider-2019-1/) (JetBrains)
* [Unit Testing Improvements in Rider 2019.1](https://blog.jetbrains.com/dotnet/2019/04/08/unit-testing-improvements-rider-2019-1/) (JetBrains)
* [Breadcrumbs, structural navigation, parameter info tooltips and more editor improvements in Rider 2019.1](http://blog.jetbrains.com/dotnet/2019/04/11/breadcrumbs-structural-navigation-parameter-info-tooltips-editor-improvements-rider-2019-1/) (JetBrains)
* [Containers? Images? An introduction to Docker in Rider](https://blog.jetbrains.com/dotnet/2019/05/21/containers-images-introduction-docker-rider/) (JetBrains)
* Awesome Plugins for Rider
  * [Language Support](https://blog.jetbrains.com/dotnet/2019/05/29/awesome-plugins-rider-language-support/) (JetBrains)
  * [Code Editing/Code Analysis](https://blog.jetbrains.com/dotnet/2019/05/31/awesome-plugins-rider-code-editinganalysis/) (JetBrains)
  * [UI/UX plugins](https://blog.jetbrains.com/dotnet/2019/06/04/awesome-plugins-rider-uiux/) (JetBrains)
* [Readme.txt support, XDT transforms, native credential providers and more Rider 2019.2  updates](https://blog.jetbrains.com/dotnet/2019/07/15/readme-txt-support-xdt-transforms-native-credential-providers-rider-2019-2--updates/) (JetBrains)
* [Fun and entertaining plugins for Rider](https://blog.jetbrains.com/dotnet/2019/07/19/fun-entertaining-plugins-rider/) (JetBrains)
* [Work effectively with JSON using Rider](https://blog.jetbrains.com/dotnet/2019/07/22/work-effectively-json-using-rider/) (JetBrains)
* [Find your perfect coding style using Rider](https://blog.jetbrains.com/dotnet/2019/07/30/find-perfect-coding-style-using-rider/) (JetBrains)
  * [Find your perfect C# style using Rider](https://blog.jetbrains.com


LocalQuizHistory quizHistory){
		return getBitmapOfQuestions(
					controller,
					quizHistory.getQuestions(),
					controller.quizApp.getUser().uid,
					quizHistory.getUsers(),
					quizHistory.maxScore,
					quizHistory.getUserAnswers1(controller.quizApp),
					quizHistory.getUserAnswers2(controller.quizApp)
				);
	}

	public void showUserInfo(List<User> users,int maxScore) {
		int index = 0;

		for(User user : users){
				if(user.uid.equalsIgnoreCase(getApp().getUser().uid)){
					users.remove(user);
					users.add(0,user);
					break;
				}
		}

		for(RelativeLayout userView : Arrays.asList((RelativeLayout) headerViewWrapper.findViewById(R.id.user1), (RelativeLayout) headerViewWrapper.findViewById(R.id.user2))){
			User user = users.get(index++);
			UserProgressViewHolder userProgressView = new UserProgressViewHolder();

			userProgressView.userNameView = ((TextView)userView.findViewById(R.id.userName));
			userProgressView.userImageView =  (ImageView)userView.findViewById(R.id.userImageSmall);

			userProgressView.userProgressView = (CustomProgressBar)userView.findViewById(R.id.userProgress);
			userProgressView.userScoreView = (TextView)userView.findViewById(R.id.userPointsEarned);
			userViews.put(user.uid, userProgressView);

			userProgressView.userNameView.setText(user.getName());
			if(!isLoadingForBitmaps){
				getApp().getUiUtils().loadImageIntoView(getApp().getContext(), userProgressView.userImageView, user.pictureUrl, false, new CircleTransform());
			}
			else
				getApp().getUiUtils().loadImageIntoViewDoInBackground(getApp().getContext(), userProgressView.userImageView, user.pictureUrl, false);

			userProgressView.userProgressView.setProgress(0);
			userProgressView.userProgressView.setMax(maxScore);

			userProgressView.userProgressView.setBackgroundResource(R.drawable.fat_progress_bar);//(getApp().getConfig().getAThemeColor());
			userProgressView.userProgressView.getProgressDrawable().setColorFilter(getApp().getConfig().getAThemeColor(), android.graphics.PorterDuff.Mode.MULTIPLY);

			userProgressView.userScoreView.setText( (!(pQuizController!=null && pQuizController.isChallengeMode()) || user.uid.equalsIgnoreCase(getApp().getUser().uid))?"+0 Xp":"?");
		}
	}
	public void animateXpPoints(String uid,  String xpPointsStr){
		userViews.get(uid).userScoreView.setText(xpPointsStr);
		animTextScale.reset();
	}

	public void animateXpPoints(String uid,  int xpPoints){
		userViews.get(uid).userScoreView.setText(xpPoints+" xp");
		animTextScale.reset();
//		TODO: uncomment below line to animate
//		userViews.get(uid).userScoreView.startAnimation(animTextScale);

//		userViews.get(uid).userScoreView.refreshDrawableState();
//		userViews.get(uid).userScoreView.invalidate();
	}

	public void animateProgressView(final String uid,final int newProgress){
		final CustomProgressBar pbar = userViews.get(uid).userProgressView;
		if(pbar==null)
			return;
		pbar.showAnimatedIncrement(newProgress);
	}

	private Boolean isOptionSelected = true;
	protected Question currentQuestion;
	private int currentQuestionIndex;

	private void showQuestion(final Question ques){
		preQuestionView.setVisibility(View.INVISIBLE);
		questionAndOptionsViewWrapper.setVisibility(View.VISIBLE);
		new Handler().postDelayed


ct", () => {
      const initialState = fromTickets.ticketsReducer(
        fromTickets.initialTicketsState,
        TicketsApiActions.loadTicketsSuccess({ tickets })
      );
      const error = new Error("http error");
      const action = TicketsApiActions.updateTicketFailure({ error });
      const state = fromTickets.ticketsReducer(initialState, action);

      expect(state.error).not.toBe(null);
      expect(state.error.toString()).toContain(error.message);
    });
  });
});
import { InvalidBirthday } from '../errors';
import { PatientBirthday } from './birthday';
import { makeBirthday } from './factories/make-birthday';

const makeSut = () => ({
  sut: makeBirthday
});

const makeFixture = (date: Date) => {
  const dateAtStartOfDay = new Date(date);

  dateAtStartOfDay.setHours(0, 0, 0, 0);

  return dateAtStartOfDay;
};

describe('Birthday Unitary Tests', () => {
  it('should create a valid birthday object', () => {
    const { sut } = makeSut();

    const fixture = makeFixture(new Date());

    const testable = sut(fixture);

    expect(testable.isRight()).toBeTruthy();

    const birthday = testable.value as PatientBirthday;

    expect(birthday.value).toEqual(fixture);
  });

  it('should validate a null param', () => {
    const { sut } = makeSut();

    const testable = sut(null);

    expect(testable.isLeft()).toBeTruthy();
    expect(testable.value).toEqual(new InvalidBirthday('Date is required'));
  });
});
import { XY, xyMap, xyRound } from '../../helper/xy';
import { CanvasRendererState } from '../../wk/canvas.defs';
import { getCanvasViewportState } from './viewport';

/*
[WORLD] (example - 10,20)
okay so entities have a xy pos in the world.
Use this to calculate distances between entities
or whatever – not hella useful in the game layer.
Youll wanna to apply zoom and get absolute pixels

[ABSOLUTE] (example - 200,400)
You can use these for anything relative to entities.
However theres also a viewport that can be panned.
this translates the position by another xy pixels.
Use this to locate a characters world coordinates in
a way where you can run calculation on screen

[VIEWPORT] (example -50, 60)
You always wanna draw at viewport position,
this is tricky. Also not super true bc the map
for example uses a tile system that idk how it maps
to anything yet it just sorta works
*/

/*
[WORLD] -> [ABS] - [VIEWPORT]
*/
export const worldToAbs = (xy: XY) =>
	xyMap(xy, (xy, k) => {
		let { zoom } = getCanvasViewportState();
		return xy[k] * zoom;
	});
export const absToViewport = (xy: XY) =>
	xyMap(xy, (xy, k) => {
		let { viewport } = getCanvasViewportState();
		return xy[k] + viewport[k];
	});
export const worldToViewport = (xy: XY) => absToViewport(worldToAbs(xy));

/*
[VIEWPORT] -> [ABS] - [WORLD]
*/
export const viewportToAbs = (xy: XY) =>
	xyMap(xy, (xy, k) => {
		let { viewport } = getCanvasViewportState();
		return xy[k] - viewport[k];
	});
export const absToWorld = (xy: XY) =>
	xyMap(xy, (xy, k) => {
		let { zoom } = getCanvasViewportState();
		return xy[k] / zoom;
	});
export const viewportToWorld = (xy: XY) =>
	xyRound(absToWorld(viewportToAbs(xy)));
namespace MyModule {
    interface Underscore {
        bind(func: Function, context: any, ...arguments: any[]): () => any;
    }

    var _: Underscore = { bind: null };

    class ErrorClass {
        private myMethod(param1:


--[[
+-------------------------------------------------------+
| cdtweaks, revised backstab immunity (component #2620) |
+-------------------------------------------------------+
--]]

-- Apply ability --

EEex_Opcode_AddListsResolvedListener(function(sprite)
	-- Sanity check
	if not EEex_GameObject_IsSprite(sprite) then
		return
	end
	--
	local general = {
		["UNDEAD"] = true,
		["WEAPON"] = true,
		["PLANT"] = true,
	}
	local race = {
		["MIST"] = true,
		["SLIME"] = true,
		["BEHOLDER"] = true,
		["DEMONIC"] = true,
		["MEPHIT"] = true,
		["IMP"] = true,
		["ELEMENTAL"] = true,
		["SALAMANDER"] = true,
		["GENIE"] = true,
		["PLANATAR"] = true,
		["DARKPLANATAR"] = true,
		["SOLAR"] = true,
		["ANTISOLAR"] = true,
		["DRAGON"] = true,
		["SHAMBLING_MOUND"] = true,
	}
	local class = {
		["GOLEM_IRON"] = true,
		["GOLEM_STONE"] = true,
		["GOLEM_CLAY"] = true,
		["GOLEM_ICE"] = true,
	}
	-- internal function that applies the actual feat
	local apply = function()
		-- Mark the creature as 'feat applied'
		sprite:setLocalInt("gtBackstabImmunity", 1)
		--
		sprite:applyEffect({
			["effectID"] = 321, -- Remove effects by resource
			[


打，这不是对政府的问题，而是同人民为敌的问题。不能把我们的错误和反革命的活动混淆起来。我们的错误要承认，要检讨，要纠正，但反革命利用我们的错误煽动破坏，就要惩办。只有这样，才能打击反革命，教育群众。当然，惩办时不要办得太多，能够不捕的就不要捕，能不枪毙的就一定不要枪毙，但总是要有适当处理，不能不处理。

   （十三）少数民族地区的镇反，要十分谨慎，可以办则办，能办多少就办多少，不要勉强。惩办少数民族中的反革命分子，要通过少数民族政权机关并少数民族群众运动结合起来。全国少数民族地区的情况也不一样，各省公安机关应根据当地少数民族地区的情况，提出镇压反革命的具体计划，报到中央来研究解决。

   （十四）康藏公路沿线的工作，要专门解决，中央公安部正在研究办法。

   （十五）镇反宣传工作，公安部准备商同中央宣传部写一个宣传工作指示，呈报中央审查发下去。

   （十六）关于一九五五年工作安排，要照顾镇反斗争的需要。同意有些同志的建议：全国民警治安模范代表会议，可以推迟到一九五六年一月再开。

   （十七）编制问题，在这里通知一下：请大家回去同党委商量一下，公安部正在拟订全国公安系统的编制计划，但一九五五年提不出来。总之是既要减少人员，又要提高工作效率，加强对敌斗争。一九五五年公安部门斗争任务还很重，精简编制的时候，注意不要妨疑斗争。要实事求是，能减多少就减多少。中央公安部的态度，就是要按国务院的指示办事，坚决持行。

   （十八）上海镇压反革命工作任务很重，情况特别复杂，饶、潘、杨都出在上海，胡风反革命集团的分子在上海的也很不少。上海过去镇压反革命很不彻底。因此，大家有支援上海的义务，要支援一批干部。中央公安部配备干部的重点是支援上海。各省、市的干部问题，要自己解决，不够的干部，可在复员军人中选一些去补充。

   （十九）敌伪档案问题。过去国民党、日本人留下大批档案，中央公安部曾发出指示，要各地把档案保留下来。因为这些档案里面有很多宝贵材料。但是不少地方对这项工作很不注意，发生了一些很严重的缺点和错误。中央很重视这件事。请大家注意，回去清查一下。今后，那个地方要是反档案随便烧掉或丢失了，要追究责任，甚至是刑事责任；哪个人把档案毁了，要查动机，看看是


acaacagcagcagcagctatagctgtgaccgctatgaggcccgtgatgacagctattaagggagactcaccaccaaggggattaccaccatcgtagctaccattagattactggtggtcagca"
				.toUpperCase());
		this.builderForward.setGeneSymbol("TTTY13");
		this.infoForward = builderForward.build();
		// RefSeq REFSEQ_ID

		GenomeVariant change1 = new GenomeVariant(new GenomePosition(refDict, Strand.FWD, refDict.getContigNameToID()
			.get("Y"), 23749506, PositionType.ZERO_BASED), "G", "");
		Annotation annotation1 = new DeletionAnnotationBuilder(infoForward, change1, new AnnotationBuilderOptions())
			.build();
		Assertions.assertEquals(infoForward.getAccession(), annotation1.getTranscript().getAccession());
		Assertions.assertEquals(3, annotation1.getAnnoLoc().getRank());
		Assertions.assertEquals("385del", annotation1.getCDSNTChange().toHGVSString());
		Assertions.assertEquals(null, annotation1.getProteinChange());
		Assertions.assertEquals(ImmutableSortedSet.of(VariantEffect.NON_CODING_TRANSCRIPT_EXON_VARIANT),
			annotation1.getEffects());
	}

	// This variant was called on the Platinum genomes and caused a problem with string access.
	@Test
	public void testRealWorldCase_uc011mcs_() throws InvalidGenomeVariant {
		this.builderForward = TranscriptModelFactory
			.parseKnownGenesLine(
				refDict,
				"uc011mcs.1	chr9	-	135782117	135820020	135782118	135798879	13	135782117,135782687,135785957,135786388,135786839,135787668,135796749,135797205,135798734,135800973,135804153,135810419,135819929,	135782222,135782757,135786079,135786500,135786955,135787844,135796823,135797360,135798879,135801126,135804339,135810482,135820020,	Q59IT9	uc011mcs.1");
		this.builderForward
			.setSequence("acgacgggggaggtgctgtacgtccaagatggcggcgccctgtaggctggagggactgtgaggtaaacagctgagggggaggagacggtggtgaccatgaaagacaccaggttgacagcactggaaactgaagtaccagttgtcgctagaacagtttggtagtggccccaatgaagaaccttcagaacctgtagcacacgtcctggagccagcacagcgccttcgagcgagagaatggcccaacaagcaaatgtcggggagcttcttgccatgctggactcccccatgctgggtgtgcgggacgacgtgacagctgtctttaaagagaacctcaattctgcacctcttggacaggattaacgaatatgtgggcaaagccgccactcgtttatccatcctctcgttactgggtcatgtcataagactgcagccatcttggaagcataagctctctcaagcacctcttttgccttctttactaaaatgtctcaagatggacactgacgtcgttgtcctcacaacaggcgtcttggtgttgataaccatgctaccaatgattccacagtctgggaaacagcatcttcttgatttctttgacatttttggccgtctgtcatcatggtgcctgaagaaaccaggccacgtggcggaagtctatctcgtccatctccatgccagtgtgtacgcactctttcatcgcctttatggaatgtacccttgcaacttcgtctcctttttgcgttctcattacagtatgaaagaaaacctggagacttttgaagaagtggtcaagccaatgatggagcatgtgcgaattcatccggaattagtgactggatc


YIRYDSYTWAVLAYLWY', 'HLA-B*58:25': 'YYATYGENMASTYENIAYLWYDSYTWAVLAYLWY', 'HLA-B*58:26': 'YYATYGENMASTYENIAYLRYDSYTWAVLAYLWY', 'HLA-B*58:27': 'YYATYGENMASTYENIAYLSYNYYTWAVLAYEWY', 'HLA-B*58:28': 'YYATYGENMASTYENIAYIRYNYYTWAVLAYLWY', 'HLA-B*58:29': 'YYATYGENMASTYENIAYIRYDSYTWAVLAYLWY', 'HLA-B*58:30': 'YYATYGENMASTYENIAYIRYDSYTWAVLAYLWY', 'HLA-B*59:01': 'YYAEYRNIFTNTYENIAYWTYNLYTWAVLAYTWY', 'HLA-B*59:02': 'YYAEYRNIFTNTYENIAYWTYNYYTWAVLAYTWY', 'HLA-B*59:03': 'YYAEYRNIFTNTYENIAYWTYNFYTWAVLAYTWY', 'HLA-B*59:04': 'YYAEYRNIFTNTYENIAYWTYNLYTWAVLAYLWY', 'HLA-B*59:05': 'YYAEYRNIFTNTYENIAYWTYNLYTWAVLAYTWY', 'HLA-B*67:01': 'YYSEYRNIYAQTDESNLYLRYNFYTWAVLTYTWY', 'HLA-B*67:02': 'YYSGYREKYRQADVSNLYLRYNFYTWAVLTYTWY', 'HLA-B*73:01': 'YHTEYRNICAKTDVGNLYWTYNFYTWAVLAYEWH', 'HLA-B*73:02': 'YHTEYRNICAKTDVGNLYWTYNFYTWAVLAYEWH', 'HLA-B*78:01': 'YYATYRNIFTNTDESNLYWTYNYYTWAELAYLWH', 'HLA-B*78:02': 'YYATYRNIFTNTYESNLYWTYNYYTWAELAYLWH', 'HLA-B*78:03': 'YYATYRNICTNTDESNLYWTYNYYTWAELAYLWH', 'HLA-B*78:04': 'YYATYRNIFTNTYESNLYWTYNYYTWAVLAYLWY', 'HLA-B*78:05': 'YYATYREISTNTYESNLYWTYNYYTWAELAYLWH', 'HLA-B*78:06': 'YYATYREISTNTYENNLYWTYNYYTWAELAYLWH', 'HLA-B*78:07': 'YYATYRNIFTNTDESNLYWTYNYYTWAELAYTWH', 'HLA-B*81:01': '


  function scrollTo (offset) {
    elements.$.scrollContainer.controller('mdVirtualRepeatContainer').scrollTo(offset);
  }

  function notFoundVisible () {
    var textLength = (ctrl.scope.searchText || '').length;

    return ctrl.hasNotFound && !hasMatches() && (!ctrl.loading || isPromiseFetching()) && textLength >= getMinLength() && (hasFocus || noBlur) && !hasSelection();
  }

  /**
   * Starts the query to gather the results for the current searchText.  Attempts to return cached
   * results first, then forwards the process to `fetchResults` if necessary.
   */
  function handleQuery () {
    var searchText = $scope.searchText || '',
        term       = searchText.toLowerCase();
    //-- if results are cached, pull in cached results
    if (!$scope.noCache && cache[ term ]) {
      ctrl.matches = cache[ term ];
      updateMessages();
    } else {
      fetchResults(searchText);
    }

    ctrl.hidden = shouldHide();
  }

  /**
   * If there is only one matching item and the search text matches its display value exactly,
   * automatically select that item.  Note: This function is only called if the user uses the
   * `md-select-on-match` flag.
   */
  function selectItemOnMatch () {
    var searchText = $scope.searchText,
        matches    = ctrl.matches,
        item       = matches[ 0 ];
    if (matches.length === 1) getDisplayValue(item).then(function (displayValue) {
      var isMatching = searchText == displayValue;
      if ($scope.matchInsensitive && !isMatching) {
        isMatching = searchText.toLowerCase() == displayValue.toLowerCase();
      }

      if (isMatching) select(0);
    });
  }

}
MdAutocompleteCtrl.$inject = ["$scope", "$element", "$mdUtil", "$mdConstant", "$mdTheming", "$window", "$animate", "$rootElement", "$attrs", "$q"];

})();
(function(){
"use strict";

angular
    .module('material.components.autocomplete')
    .directive('mdAutocomplete', MdAutocomplete);

/**
 * @ngdoc directive
 * @name mdAutocomplete
 * @module material.components.autocomplete
 *
 * @description
 * `<md-autocomplete>` is a special input component with a drop-down of all possible matches to a
 *     custom query. This component allows you to provide real-time suggestions as the user types
 *     in the input area.
 *
 * To start, you will need to specify the required parameters and provide a template for your
 *     results. The content inside `md-autocomplete` will be treated as a template.
 *
 * In more complex cases, you may want to include other content such as a message to display when
 *     no matches were found.  You can do this by wrapping your template in `md-item-template` and
 *     adding a tag for `md-not-found`.  An example of this is shown below.
 *
 * ### Validation
 *
 * You can use `ng-messages` to include validation the same way that you would normally validate;
 *     however, if you want to replicate a standard input with a floating label, you will have to
 *     do the following:
 *
 * - Make sure that your template is wrapped in `md-item-template`
 * - Add your `ng-messages` code inside of `md-autocomplete`
 * - Add your validation properties to `md-autocomplete` (ie. `required`)
 * - Add a `name` to `md-autocomplete` (to be used on the generated `input`)
 *
 * There is an example below of how this should look.
 *
 *
 * @param {expression} md-items An expression in the format of `item in items` to iterate over
 *     matches for your search.
 * @param {expression=} md-selected-item-change An expression to be run each time a new item is
 *     selected
 * @param {expression=} md-search-text-change An expression to be


           PD3

  #define TOUCH_CS_PIN                      PB6
  #define TOUCH_SCK_PIN                     PB3
  #define TOUCH_MOSI_PIN                    PB5
  #define TOUCH_MISO_PIN                    PB4
#endif

#if IS_NEWPANEL
  #define BEEPER_PIN                        PD12
  #define BTN_EN1                           PE4
  #define BTN_EN2                           PE3
  #define BTN_ENC                           PE2
  #ifndef ENCODER_STEPS_PER_MENU_ITEM
    #define ENCODER_STEPS_PER_MENU_ITEM 2
  #endif
#endif


 allowMalformed) =>
      _PercentDecoderByteSink(_sink);

  @override
  void close() => _close();

  /// Like [close], but includes [string] and [index] in the [FormatException]
  /// if one is thrown.
  void _close([String? string, int? index]) {
    if (_lastDigit != null) {
      throw FormatException(
        'Input ended with incomplete encoded byte.',
        string,
        index,
      );
    }

    _sink.close();
  }
}

/// A conversion sink for chunked percent-encoded decoding from UTF-8 bytes.
class _PercentDecoderByteSink extends ByteConversionSinkBase {
  /// The underlying sink to which decoded byte arrays will be passed.
  final Sink<List<int>> _sink;

  /// The trailing digit from the previous string.
  ///
  /// This is `null` if the previous string ended with a complete
  /// percent-encoded byte or a literal character. It's [_lastPercent] if the
  /// most recent string ended with `%`. Otherwise, the most recent string ended
  /// with a `%` followed by a hexadecimal digit, and this is that digit. Since
  /// it's the most significant digit, it's always a multiple of 16.
  int? _lastDigit;

  _PercentDecoderByteSink(this._sink);

  @override
  void add(List<int> chunk) => addSlice(chunk, 0, chunk.length, false);

  @override
  void addSlice(List<int> chunk, int start, int end, bool isLast) {
    RangeError.checkValidRange(start, end, chunk.length);

    if (start == end) {
      if (isLast) _close(chunk, end);
      return;
    }

    var buffer = Uint8Buffer();
    if (_lastDigit == _lastPercent) {
      _lastDigit = 16 * digitForCodeUnit(chunk, start);
      start++;

      if (start == end) {
        if (isLast) _close(chunk, end);
        return;
      }
    }

    if (_lastDigit != null) {
      buffer.add(_lastDigit! + digitForCodeUnit(chunk, start));
      start++;
    }

    _lastDigit = _decode(chunk, start, end, buffer);

    _sink.add(buffer.buffer.asUint8List(0, buffer.length));
    if (isLast) _close(chunk, end);
  }

  @override
  void close() => _close();

  /// Like [close], but includes [chunk] and [index] in the [FormatException]
  /// if one is thrown.
  void _close([List<int>? chunk, int? index]) {
    if (_lastDigit != null) {
      throw FormatException(
        'Input ended with incomplete encoded byte.',
        chunk,
        index,
      );
    }

    _sink.close();
  }
}

/// Decodes [codeUnits] and writes the result into [buffer].
///
/// This reads from [codeUnits] between [start] and [end]. It writes
/// the result into [buffer] starting at [end].
///
/// If there's a leftover digit at the end of the decoding, this returns that
/// digit. Otherwise it returns `null`.
int? _decode(List<int> codeUnits, int start, int end, Uint8Buffer buffer) {
  // A bitwise OR of all code units in [codeUnits]. This allows us to check for
  // out-of-range code units without adding more branches than necessary to the
  // core loop.
  var codeUnitOr = 0;

  // The beginning of the current slice of adjacent non-% characters. We can add
  // all of these to the buffer at once.
  var sliceStart = start;
  for (var i = start; i < end; i++) {
    // First, lo