case BCardType.CardType.RecoveryAndDamagePercent:
                    switch (SubType)
                    {
                        case (byte)AdditionalTypes.RecoveryAndDamagePercent.HPRecovered/10:
                            IDisposable obs = null;
                            switch (session)
                            {
                                case Character receiverCharacter:
                                    if (IsLevelScaled)
                                    {
                                        Card hcard = ServerManager.GetCardByCardId(CardId.Value);
                                        if (hcard == null)
                                        {
                                            break;
                                        }

                                        int bonus = receiverCharacter.Level / FirstData;
                                        int heal = (int)(receiverCharacter.HpLoad() * (bonus * 0.01));

                                        obs = Observable.Interval(TimeSpan.FromSeconds(ThirdData + 1 < 0 ? 2 : ThirdData + 1)).Subscribe(s =>
                                        {
                                            if (receiverCharacter.Hp > 0)
                                            {
                                                receiverCharacter.Hp = (int)(receiverCharacter.Hp + heal > receiverCharacter.HpLoad() ? receiverCharacter.HpLoad() : receiverCharacter.Hp + heal);
                                                receiverCharacter.MapInstance?.Broadcast(receiverCharacter.GenerateRc(heal));
                                                receiverCharacter.Session.SendPacket(receiverCharacter.GenerateStat());
                                            }
                                            else
                                            {
                                                obs?.Dispose();
                                            }
                                        });

                                        Observable.Timer(TimeSpan.FromSeconds(hcard.Duration * 0.1)).Subscribe(s =>
                                        {
                                            obs?.Dispose();
                                        });
                                    }
                                    break;
                            }
                            break;
                        case (SubType == (byte)AdditionalTypes.RecoveryAndDamagePercent.HPReduced/10)
                            switch (session)
                            {
                                case Character receiverCharacter:
                                    int loss = (int)(receiverCharacter.HpLoad() * (FirstData * 0.01));
                                    IDisposable rObs;
                                    Card rCard = ServerManager.GetCardByCardId(CardId.value);

                                    if (rCard == null)
                                    {
                                        return;
                                    }

                                    if (rCard.Duration <= 0)
                                    {
                                        receiverCharacter.DotDebuff = Observable.Interval(TimeSpan.FromSeconds(ThirdData + 1)).Subscribe(s =>
                                        {
                                            if (receiverCharacter.Hp > 0)
                                            {
                                                receiverCharacter.Hp = receiverCharacter.Hp - loss <= 0 ? 1 : receiverCharacter.Hp - loss;
                                                receiverCharacter.MapInstance?.Broadcast(receiverCharacter.GenerateDm((ushort)loss));
                                                receiverCharacter.Session.SendPacket(receiverCharacter.GenerateStat());
                                            }
                                        });
                                        break;
                                    }

                                    rObs = Observable.Interval(TimeSpan.FromSeconds(ThirdData + 1)).Subscribe(s =>
                                    {
                                        if (receiverCharacter.Hp > 0)
                                        {
                                            receiverCharacter.Hp = receiverCharacter.Hp - loss <= 0 ? 1 : receiverCharacter.Hp - loss;
                                            receiverCharacter.MapInstance?.Broadcast(receiverCharacter.GenerateDm((ushort)loss));
                                            receiverCharacter.Session.SendPacket(receiverCharacter.GenerateStat());
                                        }
                                    });

                                    Observable.Timer(TimeSpan.FromSeconds(rCard.Duration * 0.1)).Subscribe(s =>
                                    {
                                        rObs.Dispose();
                                    });

                                    break;
                            }
                            break;
                    }
                    break;