#import "IdiomPinView.h"
#import "UIImageView+WebCache.h"
#import "UIImage+TryImage.h"
#import "FixMaterial.h"
#import "NSString+EasyStorm.h"
#import "BinAlertView.h"
#import "PatchReplyBothWindow.h"
#import "LemmaFormPowerViewController.h"
#import "UIDevice+TooDevice.h"
#import "NextBeganManager.h"

@interface IdiomPinView()  <UIGestureRecognizerDelegate> {
    CGPoint receiveAdditionsBrandKeepDetailMetrics;
    BOOL labeledAdverbEnclosingGreenRefreshed;
    BOOL claimYearLengthsLanguagesFoldOld; 
    BOOL disablingUsesTradHeartMax; 
}


@property (nonatomic, strong) PatchReplyBothWindow *subOverageWindow;
@property (nonatomic, weak) UIWindow *violationWetWindow;


@property (nonatomic, strong) UIImageView *recoveredView;
@property (nonatomic, strong) UIView *membersRateView;


@property (nonatomic, strong) UIView *badPrefixView;
@property (nonatomic, strong) UILabel *interruptLabel;
@property (nonatomic, assign) BOOL trashFactorDeveloperFoodNickname;


@property (nonatomic, strong) NSTimer *northLikeWarpTimer;
@property (nonatomic, assign) UIEdgeInsets metalSinLowGetOld;
@property (nonatomic, assign) CGRect committedDirectionReportsCheckFullRed;


@property (nonatomic, strong) UIImage *redLoadDarkImage;
@property (nonatomic, copy) NSString *unitThicknessStreamedSixApple;
@property (nonatomic, strong) UIImage *alpineDayImage;
@property (nonatomic, assign) CGFloat leadMostSmooth;
@property (nonatomic, assign) BoxKeyMostlyEdge altitudeBookEdge;
@property (nonatomic, assign) NSTimeInterval transposeLanguagesLegacyTryTab;
@property (nonatomic, assign) BOOL auditAggregateOperandActiveProvidersTeam;
@end

@implementation IdiomPinView


+ (instancetype)shared {
    static IdiomPinView *instance = nil;
    static dispatch_once_t blueToken;
    dispatch_once(&blueToken, ^{
        instance = [[super alloc] initWithFrame:CGRectZero];
        [instance ornamentsHellmanForkSobUnit];
    });
    return instance;
}

- (UIView *)membersRateView {
    if (!_membersRateView) {
        _membersRateView = [[UIView alloc] initWithFrame:CGRectMake(0, 0, 8, 8)];
        _membersRateView.backgroundColor = UIColor.redColor;
        _membersRateView.layer.cornerRadius = 4;
        _membersRateView.hidden = YES;
    }
    return _membersRateView;
}

- (void)ornamentsHellmanForkSobUnit {
    self.leadMostSmooth = 10.0;
    self.transposeLanguagesLegacyTryTab = 3.0;
    self.auditAggregateOperandActiveProvidersTeam = YES;
    
    
    self.recoveredView = [[UIImageView alloc] init];
    self.recoveredView.contentMode = UIViewContentModeScaleAspectFit;
    [self addSubview:self.recoveredView];
    
    self.badPrefixView = [[UIView alloc] init];
    self.badPrefixView.backgroundColor = [UIColor colorWithWhite:0 alpha:0.7];
    self.badPrefixView.layer.cornerRadius = 20;
    self.badPrefixView.layer.masksToBounds = YES;
    self.badPrefixView.alpha = 0.0;
    
    self.interruptLabel = [[UILabel alloc] initWithFrame:CGRectMake(0, 0, 80, 40)];
    self.interruptLabel.text = FixMaterial.dryMicroCapTag.birthFinderUnsignedSequenceWorkingInteger;
    self.interruptLabel.numberOfLines = 0;
    self.interruptLabel.textColor = [UIColor whiteColor];
    self.interruptLabel.textAlignment = NSTextAlignmentCenter;
    self.interruptLabel.font = [UIFont systemFontOfSize:14];
    [self.badPrefixView addSubview:self.interruptLabel];
    
    
    UIPanGestureRecognizer *pan = [[UIPanGestureRecognizer alloc]
                                   initWithTarget:self
                                   action:@selector(panMediaEggNap:)];
    pan.delegate = self;
    [self addGestureRecognizer:pan];
    
    UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc]
                                   initWithTarget:self
                                   action:@selector(keyBinRawDutch)];
    [self addGestureRecognizer:tap];
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
    
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(keysJobSafariProgressTwoHit)
                                                 name:UIApplicationDidChangeStatusBarOrientationNotification
                                               object:nil];
#pragma clang diagnostic pop
}

- (void)setWetKinHangJson:(NSDictionary *)wetKinHangJson {
    _wetKinHangJson = wetKinHangJson;
    if (wetKinHangJson && self.subOverageWindow != nil) {
        NSString *action = wetKinHangJson[FixMaterial.capsLoopsAge.sleetOnceDance];
        if ([action isEqualToString:FixMaterial.capsLoopsAge.trySameThumb]) {
            self.membersRateView.hidden = NO;
        }else if ([action isEqualToString:FixMaterial.capsLoopsAge.starLawOuter]) {
            self.membersRateView.hidden = YES;
        }else if ([action isEqualToString:FixMaterial.capsLoopsAge.notationConvertedBinSumFinal]) {
            self.membersRateView.hidden = NO;
        }
    }
}


+ (void)deciliter {
    [self.shared launchedOutputHueInitialClearedAnyImage:[UIImage tabularFinishAudiencesKinTriggeredName:FixMaterial.capsLoopsAge.malformedChinaTakeContentShot] kindGain:FixMaterial.slabPauseArtsPassiveMen treeImage:nil];
}

+ (void)canonTalkMindImage:(UIImage *)image {
    [[self shared] launchedOutputHueInitialClearedAnyImage:image treeImage:nil];
}

+ (void)niacinFocusImage:(UIImage *)normalImage treeImage:(nullable UIImage *)treeImage {
    IdiomPinView *instance = [self shared];
    instance.redLoadDarkImage = normalImage;
    instance.unitThicknessStreamedSixApple = nil;
    instance.alpineDayImage = treeImage;
    instance.recoveredView.image = normalImage;
}

+ (void)longClean {
    [[self shared] faxEnablingDecimalBookCopyright];
}

+ (BOOL)thatSameTooBed {
    return [self shared].subOverageWindow != nil;
}


- (void)launchedOutputHueInitialClearedAnyImage:(UIImage *)image treeImage:(nullable UIImage *)treeImage {
    [self launchedOutputHueInitialClearedAnyImage:image kindGain:nil treeImage:treeImage];
}

- (void)launchedOutputHueInitialClearedAnyImage:(UIImage *)image kindGain:(NSString *)kindGain treeImage:(nullable UIImage *)treeImage {
    dispatch_async(dispatch_get_main_queue(), ^{
        self.redLoadDarkImage = image;
        self.unitThicknessStreamedSixApple = kindGain;
        self.alpineDayImage = treeImage;
        
        if (!self.subOverageWindow) {
            [self disableSaltExceptionFloatingEvaluatedWindow];
            [self ageZeroEncodeCreditsStill];
            [self sideTelephoneEligibleHisRankedLight];
            [self magneticBiotinRopeNineDaughtersOpaque]; 
        }
        
        [self.subOverageWindow makeKeyAndVisible];
        [self.violationWetWindow makeKeyWindow];
        
        [self existingCircularPerfusionDigitEditScalingAnimation:YES];
        [self numeralSnowTerahertzBevelDisplayTimer];
    });
}

- (void)faxEnablingDecimalBookCopyright {
    dispatch_async(dispatch_get_main_queue(), ^{
        [self.subOverageWindow resignKeyWindow];
        self.subOverageWindow.hidden = YES;
        self.subOverageWindow = nil;
    });
}


- (void)disableSaltExceptionFloatingEvaluatedWindow {
    
    self.violationWetWindow = [self checkingPasswordPaddleOpenResultsWindow];
    
    
    PatchReplyBothWindow *window = nil;
    
    
    if (@available(iOS 13.0, *)) {
        for (UIScene *scene in [UIApplication sharedApplication].connectedScenes) {
            if (scene.activationState == UISceneActivationStateForegroundActive &&
                [scene isKindOfClass:[UIWindowScene class]]) {
                window = [[PatchReplyBothWindow alloc] initWithWindowScene:(UIWindowScene *)scene];
                break;
            }
        }
    }
    
    
    if (!window) {
        window = [[PatchReplyBothWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];
    }
    
    
    window.backgroundColor = [UIColor clearColor];
    window.clipsToBounds = YES; 
    window.windowLevel = UIWindowLevelAlert + 1000;
    window.backgroundColor = [UIColor clearColor];
    window.rootViewController = [[LemmaFormPowerViewController alloc] init];
    window.hidden = NO;
    self.subOverageWindow = window;
    
    
    [self.subOverageWindow resignKeyWindow];
    [self.violationWetWindow makeKeyWindow];
    
    
    [self addSubview:self.membersRateView];
    
    
    self.frame = CGRectMake(0, 0, 60, 60);
    if (self.unitThicknessStreamedSixApple) {
        [self.recoveredView sd_setImageWithURL:[NSURL URLWithString:self.unitThicknessStreamedSixApple] placeholderImage
                                              :[UIImage tabularFinishAudiencesKinTriggeredName:FixMaterial.capsLoopsAge.malformedChinaTakeContentShot]
                                       options:(SDWebImageDelayPlaceholder)];
    }else {
        self.recoveredView.image = self.redLoadDarkImage;
    }
    self.recoveredView.frame = self.bounds;
    
    [self.subOverageWindow addSubview:self];
    [self.subOverageWindow addSubview:self.badPrefixView];
}


- (void)magneticBiotinRopeNineDaughtersOpaque {
    CGRect archiveBleed = self.committedDirectionReportsCheckFullRed;
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
    UIInterfaceOrientation orientation = [UIApplication sharedApplication].statusBarOrientation;
#pragma clang diagnostic pop
    
    if (UIInterfaceOrientationIsLandscape(orientation)) {
        CGFloat quiet = 180;
        self.badPrefixView.frame = CGRectMake(
         (archiveBleed.size.width - quiet)/2,
          archiveBleed.size.height - quiet/2,
          quiet,
          quiet
        );
        self.badPrefixView.layer.masksToBounds = YES;
        self.badPrefixView.layer.cornerRadius = quiet/2;
        self.interruptLabel.center = CGPointMake(quiet/2, quiet/4);
    }
    
    else {
        CGFloat quiet = 240;
        self.badPrefixView.frame = CGRectMake(

          (archiveBleed.size.width - quiet/2),
          archiveBleed.size.height - quiet/2,
          quiet,
          quiet
        );
        self.badPrefixView.layer.masksToBounds = YES;
        self.badPrefixView.layer.cornerRadius = quiet/2;
        self.interruptLabel.center = CGPointMake(quiet/3, quiet/4);
    }
}


- (void)keyBinRawDutch {
    if (self.wetKinHangJson) {
        !self.firstKeyHandler ?: self.firstKeyHandler(self.wetKinHangJson[FixMaterial.capsLoopsAge.optEasyFact]);
        if ([self.wetKinHangJson[FixMaterial.capsLoopsAge.sleetOnceDance] isEqualToString:FixMaterial.capsLoopsAge.notationConvertedBinSumFinal]) {
            self.membersRateView.hidden = YES;
            _wetKinHangJson = nil;
        }
    }else {
        !self.firstKeyHandler ?: self.firstKeyHandler(nil);
    }
}

- (void)panMediaEggNap:(UIPanGestureRecognizer *)gesture {
    if (labeledAdverbEnclosingGreenRefreshed) return;
        
    CGPoint translation = [gesture translationInView:self.superview];
    
    switch (gesture.state) {
        case UIGestureRecognizerStateBegan:
            receiveAdditionsBrandKeepDetailMetrics = self.center;
            _recoveredView.alpha = 1;
            [self lockOperatorControlCarHer];
            claimYearLengthsLanguagesFoldOld = NO; 
            disablingUsesTradHeartMax = NO; 
            
            
            [self.layer removeAllAnimations];
            [self.badPrefixView.layer removeAllAnimations];
            
            
            self.badPrefixView.alpha = 0.0;
            self.badPrefixView.transform = CGAffineTransformIdentity;
            break;
            
        case UIGestureRecognizerStateChanged:{
            
            self.center = [self pinkNewtonsMongolianDoneLeftBigCentersCenter:
                           CGPointMake(receiveAdditionsBrandKeepDetailMetrics.x + translation.x,
                                       receiveAdditionsBrandKeepDetailMetrics.y + translation.y)];
            
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
            
            BOOL RowTraverse = UIInterfaceOrientationIsLandscape([UIApplication sharedApplication].statusBarOrientation);
#pragma clang diagnostic pop
            CGRect ironFrame = self.badPrefixView.frame;
            CGRect sixNiacin = CGRectInset(ironFrame, -280, RowTraverse?-100:-280); 
            BOOL dragPriorAsk = CGRectContainsPoint(sixNiacin, self.center);
            
            
            
            
            if (dragPriorAsk != disablingUsesTradHeartMax) {
                disablingUsesTradHeartMax = dragPriorAsk;
                
                
                [UIView animateWithDuration:0.3
                                      delay:0
                                    options:UIViewAnimationOptionBeginFromCurrentState
                                 animations:^{
                    self.badPrefixView.alpha = dragPriorAsk ? 1.0 : 0.0;
                    self.badPrefixView.transform = dragPriorAsk ? CGAffineTransformMakeScale(1.2, 1.2) : CGAffineTransformIdentity;
                } completion:nil];
            }
            
            
            dragPriorAsk = CGRectContainsPoint(CGRectInset(ironFrame, 0, 0), self.center);
            if (dragPriorAsk && !claimYearLengthsLanguagesFoldOld) {
                UIImpactFeedbackGenerator *feedback = [[UIImpactFeedbackGenerator alloc] initWithStyle:UIImpactFeedbackStyleMedium];
                [feedback prepare]; 
                [feedback impactOccurred];
                claimYearLengthsLanguagesFoldOld = YES;
                
                
                [UIView animateWithDuration:0.3
                                      delay:0
                                    options:UIViewAnimationOptionBeginFromCurrentState
                                 animations:^{
                    self.badPrefixView.transform = CGAffineTransformMakeScale(1.3, 1.3);
                } completion:nil];
            } else if (!dragPriorAsk) {
                if (claimYearLengthsLanguagesFoldOld) {
                    self.badPrefixView.transform = CGAffineTransformMakeScale(1.2, 1.2);
                }
                claimYearLengthsLanguagesFoldOld = NO;
            }
            
            
            sixNiacin = CGRectInset(ironFrame, 0, 0);
            _trashFactorDeveloperFoodNickname = CGRectContainsPoint(sixNiacin, self.center);
            break;
        }
            
        case UIGestureRecognizerStateEnded:
        case UIGestureRecognizerStateCancelled: {
            
            [UIView animateWithDuration:0.3 animations:^{
                self.badPrefixView.alpha = 0.0;
                self.badPrefixView.transform = CGAffineTransformIdentity;
            }];
            
            if (_trashFactorDeveloperFoodNickname) {
                [BinAlertView bigUnboundedMaintainUnpluggedTargetGrouped:nil message:FixMaterial.dryMicroCapTag.smallHeavyHueTheGoldenGet sixPerformed:@[FixMaterial.dryMicroCapTag.seeExtraHis, FixMaterial.dryMicroCapTag.working] completion:^(NSInteger sixSawIndex) {
                    if (sixSawIndex ==1) {
                        [self faxEnablingDecimalBookCopyright];
                    }else {
                        [self existingCircularPerfusionDigitEditScalingAnimation:YES];
                        [self numeralSnowTerahertzBevelDisplayTimer];
                    }
                }];
            } else {
                [self existingCircularPerfusionDigitEditScalingAnimation:YES];
                [self numeralSnowTerahertzBevelDisplayTimer];
            }
            claimYearLengthsLanguagesFoldOld = NO;
            disablingUsesTradHeartMax = NO;
            break;
        }

        default: break;
    }
}


- (void)existingCircularPerfusionDigitEditScalingAnimation:(BOOL)animate {
    if (!_auditAggregateOperandActiveProvidersTeam) return;
    
    
    if (labeledAdverbEnclosingGreenRefreshed && animate) return;
    
    CGRect fairFrame = [self catMinPanoramasAbnormalModelFrame];
    CGPoint center = self.center;
    
    CGFloat post = fairFrame.origin.x;
    CGFloat male = fairFrame.origin.x + fairFrame.size.width;
    CGFloat turn = fairFrame.origin.y;
    CGFloat team = fairFrame.origin.y + fairFrame.size.height;
    
    
    BoxKeyMostlyEdge squareEdge = RetPrimeMusicQuarterTruncatedSmoothing;
    CGFloat spaYearsOur = CGFLOAT_MAX;
    
    
    CGFloat boxCat = center.x - post;
    CGFloat dogLazy = male - center.x;
    CGFloat occur = center.y - turn;
    CGFloat wordWalk = team - center.y;
    
    NSArray *upperFade = @[@(boxCat), @(dogLazy), @(occur), @(wordWalk)];
    NSArray *edges = @[@(ThirteenDismissalCardVignetteModalDeliver), @(IntentsExpectingRunRankedHandoverEqual),
                       @(ResignSafeSoftnessExceedsOdd), @(WaitExpertRemovableWetDownhillBound)];
    
    for (NSInteger i = 0; i < upperFade.count; i++) {
        CGFloat distance = [upperFade[i] floatValue];
        if (distance < spaYearsOur) {
            spaYearsOur = distance;
            squareEdge = [edges[i] integerValue];
        }
    }
    
    
    if (squareEdge == self.altitudeBookEdge) {
        CGPoint notFormCenter = self.center;
        CGPoint reasonCenter = [self kilometerQueryingSmileLockingEnvelopeEndsEdge:squareEdge];
        CGFloat distance = hypot(notFormCenter.x - reasonCenter.x, notFormCenter.y - reasonCenter.y);
        if (distance < 5.0) { 
            return;
        }
    }
    
    self.altitudeBookEdge = squareEdge;
    
    
    CGPoint reasonCenter = [self kilometerQueryingSmileLockingEnvelopeEndsEdge:squareEdge];
    CGPoint basicCenter = [self catClickedLighterIrishApplyingPrepSettingEdge:squareEdge];
    
    
    labeledAdverbEnclosingGreenRefreshed = YES;
    
    
    [CATransaction begin];
    [CATransaction setCompletionBlock:^{
        self->labeledAdverbEnclosingGreenRefreshed = NO;
    }];
    
    [UIView animateWithDuration:animate ? 0.3 : 0
                     animations:^{
        self.center = reasonCenter;
        self.membersRateView.center = basicCenter;
    }];
    
    [CATransaction commit];
}


- (CGPoint)kilometerQueryingSmileLockingEnvelopeEndsEdge:(BoxKeyMostlyEdge)edge {
    CGRect fairFrame = [self catMinPanoramasAbnormalModelFrame];
    CGPoint center = self.center;
    
    CGFloat post = fairFrame.origin.x;
    CGFloat male = fairFrame.origin.x + fairFrame.size.width;
    CGFloat turn = fairFrame.origin.y;
    CGFloat team = fairFrame.origin.y + fairFrame.size.height;
    
    CGPoint reasonCenter = center;
    
    switch (edge) {
        case ThirteenDismissalCardVignetteModalDeliver:
            reasonCenter.x = post + self.bounds.size.width/2 + _leadMostSmooth;
            break;
        case IntentsExpectingRunRankedHandoverEqual:
            reasonCenter.x = male - self.bounds.size.width/2 - _leadMostSmooth;
            break;
        case ResignSafeSoftnessExceedsOdd:
            reasonCenter.y = turn + self.bounds.size.height/2 + _leadMostSmooth;
            break;
        case WaitExpertRemovableWetDownhillBound:
            reasonCenter.y = team - self.bounds.size.height/2 - _leadMostSmooth;
            break;
        default:
            break;
    }
    
    
    return [self pinkNewtonsMongolianDoneLeftBigCentersCenter:reasonCenter];
}


- (CGPoint)catClickedLighterIrishApplyingPrepSettingEdge:(BoxKeyMostlyEdge)edge {
    CGPoint basicCenter = CGPointMake(0, 0);
    
    switch (edge) {
        case ThirteenDismissalCardVignetteModalDeliver:
            basicCenter.x = self.bounds.size.width;
            break;
        case IntentsExpectingRunRankedHandoverEqual:
            
            break;
        case ResignSafeSoftnessExceedsOdd:
            basicCenter.x = self.bounds.size.width;
            basicCenter.y = self.bounds.size.height;
            break;
        case WaitExpertRemovableWetDownhillBound:
            basicCenter.x = self.bounds.size.width;
            break;
        default:
            break;
    }
    
    return basicCenter;
}


- (void)numeralSnowTerahertzBevelDisplayTimer {
    if (_transposeLanguagesLegacyTryTab <= 0) return;
    
    [self lockOperatorControlCarHer];
    _northLikeWarpTimer = [NSTimer scheduledTimerWithTimeInterval:_transposeLanguagesLegacyTryTab
                                                     target:self
                                                   selector:@selector(freestyleMandatoryReduceDividerVortex)
                                                   userInfo:nil
                                                    repeats:NO];
}

- (void)lockOperatorControlCarHer {
    [_northLikeWarpTimer invalidate];
    _northLikeWarpTimer = nil;
}

- (void)freestyleMandatoryReduceDividerVortex {
    [UIView animateWithDuration:0.3 animations:^{
        self.recoveredView.alpha = 0.5;
        
        CGRect frame = self.frame;
        switch (self.altitudeBookEdge) {
            case ThirteenDismissalCardVignetteModalDeliver:
                frame.origin.x -= self.leadMostSmooth;
                break;
            case IntentsExpectingRunRankedHandoverEqual:
                frame.origin.x += self.leadMostSmooth;
                break;
            case ResignSafeSoftnessExceedsOdd:
                frame.origin.y -= self.leadMostSmooth;
                break;
            case WaitExpertRemovableWetDownhillBound:
                frame.origin.y += self.leadMostSmooth;
                break;
            default:
                break;
        }
        self.frame = frame;
    }];
}


- (void)keysJobSafariProgressTwoHit {
    [self ageZeroEncodeCreditsStill];
    [self magneticBiotinRopeNineDaughtersOpaque]; 
    [self existingCircularPerfusionDigitEditScalingAnimation:YES];
}


- (void)ageZeroEncodeCreditsStill {
    UIWindow *keyWindow = NextBeganManager.shared.bedHasEnableWindow; //self.violationWetWindow;
    UIEdgeInsets safeArea = UIEdgeInsetsZero;
    if (![UIDevice guestToo]) {
        safeArea = UIEdgeInsetsZero;
    }else if([UIDevice askAsk]) {
        safeArea = UIEdgeInsetsMake(0, 0, 20, 0);
    }else {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
        UIInterfaceOrientation orientation = [[UIApplication sharedApplication] statusBarOrientation];
#pragma clang diagnostic pop
        safeArea = keyWindow.safeAreaInsets;
        switch (orientation) {
            case UIInterfaceOrientationPortrait:
                safeArea = UIEdgeInsetsMake(safeArea.top-10, 5, 15, 5);
                break;
            case UIInterfaceOrientationPortraitUpsideDown:
                safeArea = UIEdgeInsetsMake(15, 5, safeArea.bottom-10, 5);
                break;
            case UIInterfaceOrientationLandscapeRight:
                safeArea = UIEdgeInsetsMake(5, safeArea.right-10, 15, 5);
                break;
            case UIInterfaceOrientationLandscapeLeft:
                safeArea = UIEdgeInsetsMake(5, 5, 15, safeArea.left-10);
                break;
            case UIInterfaceOrientationUnknown:
            default:
                safeArea = safeArea;
        }
    }
    
    self.metalSinLowGetOld = safeArea;
    self.committedDirectionReportsCheckFullRed = keyWindow.bounds;
}

- (CGRect)catMinPanoramasAbnormalModelFrame {
    
    return CGRectMake(
        self.committedDirectionReportsCheckFullRed.origin.x + self.metalSinLowGetOld.left,
        self.committedDirectionReportsCheckFullRed.origin.y + self.metalSinLowGetOld.top,
        self.committedDirectionReportsCheckFullRed.size.width - (self.metalSinLowGetOld.left + self.metalSinLowGetOld.right),
        self.committedDirectionReportsCheckFullRed.size.height - (self.metalSinLowGetOld.top + self.metalSinLowGetOld.bottom)
    );
}


- (void)sideTelephoneEligibleHisRankedLight {
    NSString *tabGlyphFeet = [[NSUserDefaults standardUserDefaults] valueForKey:FixMaterial.capsLoopsAge.freezingRetryUrgentEnergyCycleImperial];
    if (tabGlyphFeet) {
        self.center = CGPointFromString(tabGlyphFeet);
    }else {
        
        CGRect fairFrame = [self catMinPanoramasAbnormalModelFrame];
        self.center = CGPointMake(fairFrame.origin.x + fairFrame.size.width - self.bounds.size.width/2 - _leadMostSmooth,
                                  fairFrame.origin.y + fairFrame.size.height/2);
    }
}


- (UIWindow *)checkingPasswordPaddleOpenResultsWindow {
    if (@available(iOS 13.0, *)) {
        NSSet<UIScene *> *scenes = [UIApplication sharedApplication].connectedScenes;
        for (UIScene *scene in scenes) {
            if (scene.activationState == UISceneActivationStateForegroundActive &&
                [scene isKindOfClass:[UIWindowScene class]]) {
                UIWindowScene *windowScene = (UIWindowScene *)scene;
                return windowScene.windows.firstObject;
            }
        }
    }
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
    return [UIApplication sharedApplication].keyWindow;
#pragma clang diagnostic pop
}

- (CGPoint)pinkNewtonsMongolianDoneLeftBigCentersCenter:(CGPoint)proposedCenter {
    CGRect fairFrame = [self catMinPanoramasAbnormalModelFrame];
    CGSize buttonSize = self.bounds.size;
    
    CGFloat post = fairFrame.origin.x + buttonSize.width/2;
    CGFloat male = fairFrame.origin.x + fairFrame.size.width - buttonSize.width/2;
    CGFloat turn = fairFrame.origin.y + buttonSize.height/2;
    CGFloat team = fairFrame.origin.y + fairFrame.size.height - buttonSize.height/2;
    
    return CGPointMake(
        MAX(post, MIN(proposedCenter.x, male)),
        MAX(turn, MIN(proposedCenter.y, team))
    );
}

- (void)dealloc {
    [[NSNotificationCenter defaultCenter] removeObserver:self];
}

@end