#import "EraEqualView.h"
#import "UIImageView+WebCache.h"
#import "UIImage+LawImage.h"
#import "AffectedBus.h"
#import "NSString+NoiseFold.h"
#import "PutAlertView.h"
#import "CubeLeaseMinorWindow.h"
#import "ArrowHeartbeatViewController.h"
#import "UIDevice+MenDevice.h"
#import "FutureDryManager.h"

@interface EraEqualView()  <UIGestureRecognizerDelegate> {
    CGPoint zoomTallMixSortComposedStale;
    BOOL artistBoundingThickOrderedAppended;
    BOOL insetRestartHailPinkSmoothingBaltic; 
    BOOL irishConsumedFoldActivatedDanish; 
}


@property (nonatomic, strong) CubeLeaseMinorWindow *fixNoneManWindow;
@property (nonatomic, weak) UIWindow *rareLeaseTooWindow;


@property (nonatomic, strong) UIImageView *correctedView;
@property (nonatomic, strong) UIView *operandOnceView;


@property (nonatomic, strong) UIView *putSubsetView;
@property (nonatomic, strong) UILabel *downVowelLabel;
@property (nonatomic, assign) BOOL defineTexturedWakeAffiliateNordic;


@property (nonatomic, strong) NSTimer *optimizedOnceTimer;
@property (nonatomic, assign) UIEdgeInsets connectFisheyeMattingProxyEntries;
@property (nonatomic, assign) CGRect farTodayStrictlyDayShapePaste;


@property (nonatomic, strong) UIImage *wetExactHerImage;
@property (nonatomic, copy) NSString *georgianWayFoldSlantMalay;
@property (nonatomic, strong) UIImage *gainBloodImage;
@property (nonatomic, assign) CGFloat parseQueryKind;
@property (nonatomic, assign) SlowHoverWetEdge nanogramsCutEdge;
@property (nonatomic, assign) NSTimeInterval expandedFastUtteranceReadableStatic;
@property (nonatomic, assign) BOOL warpSaveCarBarAboveIndigo;
@end

@implementation EraEqualView


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

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

- (void)arrangedBurstPushDestroyEye {
    self.parseQueryKind = 10.0;
    self.expandedFastUtteranceReadableStatic = 3.0;
    self.warpSaveCarBarAboveIndigo = YES;
    
    
    self.correctedView = [[UIImageView alloc] init];
    self.correctedView.contentMode = UIViewContentModeScaleAspectFit;
    [self addSubview:self.correctedView];
    
    self.putSubsetView = [[UIView alloc] init];
    self.putSubsetView.backgroundColor = [UIColor colorWithWhite:0 alpha:0.7];
    self.putSubsetView.layer.cornerRadius = 20;
    self.putSubsetView.layer.masksToBounds = YES;
    self.putSubsetView.alpha = 0.0;
    
    self.downVowelLabel = [[UILabel alloc] initWithFrame:CGRectMake(0, 0, 80, 40)];
    self.downVowelLabel.text = AffectedBus.delayOceanMale.flagOrdinalsCapCameraAddBag;
    self.downVowelLabel.numberOfLines = 0;
    self.downVowelLabel.textColor = [UIColor whiteColor];
    self.downVowelLabel.textAlignment = NSTextAlignmentCenter;
    self.downVowelLabel.font = [UIFont systemFontOfSize:14];
    [self.putSubsetView addSubview:self.downVowelLabel];
    
    
    UIPanGestureRecognizer *pan = [[UIPanGestureRecognizer alloc]
                                   initWithTarget:self
                                   action:@selector(moreOrangeMill:)];
    pan.delegate = self;
    [self addGestureRecognizer:pan];
    
    UITapGestureRecognizer *hit = [[UITapGestureRecognizer alloc]
                                   initWithTarget:self
                                   action:@selector(audioMastering)];
    [self addGestureRecognizer:hit];
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
    
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(kilowattsExecutingCovariantCursorsCentralUnplugged)
                                                 name:UIApplicationDidChangeStatusBarOrientationNotification
                                               object:nil];
#pragma clang diagnostic pop
}

- (void)setPopFairCanJson:(NSDictionary *)popFairCanJson {
    _popFairCanJson = popFairCanJson;
    if (popFairCanJson && self.fixNoneManWindow != nil) {
        NSString *action = popFairCanJson[AffectedBus.mixProviders.loudHexBondPop];
        if ([action isEqualToString:AffectedBus.mixProviders.dropItsTitle]) {
            self.operandOnceView.hidden = NO;
        }else if ([action isEqualToString:AffectedBus.mixProviders.hexWideStart]) {
            self.operandOnceView.hidden = YES;
        }else if ([action isEqualToString:AffectedBus.mixProviders.updatesMovementPrototypeEncodedAsk]) {
            self.operandOnceView.hidden = NO;
        }
    }
}


+ (void)radioExec {
    [self.shared redHockeyPreviewsAssameseWarnIllegalImage:[UIImage softnessTableProtectedDisablesChunkyName:AffectedBus.mixProviders.favoritesSnapWhoGallonsGeometry] slopeRow:AffectedBus.cyclingHardFocusedLoadingOver goalImage:nil];
}

+ (void)motionAdjustsImage:(UIImage *)image {
    [[self shared] redHockeyPreviewsAssameseWarnIllegalImage:image goalImage:nil];
}

+ (void)ownArmAlignImage:(UIImage *)normalImage goalImage:(nullable UIImage *)goalImage {
    EraEqualView *instance = [self shared];
    instance.wetExactHerImage = normalImage;
    instance.georgianWayFoldSlantMalay = nil;
    instance.gainBloodImage = goalImage;
    instance.correctedView.image = normalImage;
}

+ (void)prettyCut {
    [[self shared] ornamentsNameScalarInvertSequences];
}

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


- (void)redHockeyPreviewsAssameseWarnIllegalImage:(UIImage *)image goalImage:(nullable UIImage *)goalImage {
    [self redHockeyPreviewsAssameseWarnIllegalImage:image slopeRow:nil goalImage:goalImage];
}

- (void)redHockeyPreviewsAssameseWarnIllegalImage:(UIImage *)image slopeRow:(NSString *)slopeRow goalImage:(nullable UIImage *)goalImage {
    dispatch_async(dispatch_get_main_queue(), ^{
        self.wetExactHerImage = image;
        self.georgianWayFoldSlantMalay = slopeRow;
        self.gainBloodImage = goalImage;
        
        if (!self.fixNoneManWindow) {
            [self ambiguousJobRankAssumeSampleWindow];
            [self cutoffTouchesSlabCombineChecked];
            [self coverageFigureSpecifyWindowFlippedWalking];
            [self frictionSelectorLengthFlashUnderageRemoval]; 
        }
        
        [self.fixNoneManWindow makeKeyAndVisible];
        [self.rareLeaseTooWindow makeKeyWindow];
        
        [self sexAbortRenewalRelativeEscapeImmediateAnimation:YES];
        [self achievedSixteenCanceledTheTriggerTimer];
    });
}

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


- (void)ambiguousJobRankAssumeSampleWindow {
    
    self.rareLeaseTooWindow = [self optRectumSliderGuaraniDefaultsWindow];
    
    
    CubeLeaseMinorWindow *window = nil;
    
    
    if (@available(iOS 13.0, *)) {
        for (UIScene *scene in [UIApplication sharedApplication].connectedScenes) {
            if (scene.activationState == UISceneActivationStateForegroundActive &&
                [scene isKindOfClass:[UIWindowScene class]]) {
                window = [[CubeLeaseMinorWindow alloc] initWithWindowScene:(UIWindowScene *)scene];
                break;
            }
        }
    }
    
    
    if (!window) {
        window = [[CubeLeaseMinorWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];
    }
    
    
    window.backgroundColor = [UIColor clearColor];
    window.clipsToBounds = YES; 
    window.windowLevel = UIWindowLevelAlert + 1000;
    window.backgroundColor = [UIColor clearColor];
    window.rootViewController = [[ArrowHeartbeatViewController alloc] init];
    window.hidden = NO;
    self.fixNoneManWindow = window;
    
    
    [self.fixNoneManWindow resignKeyWindow];
    [self.rareLeaseTooWindow makeKeyWindow];
    
    
    [self addSubview:self.operandOnceView];
    
    
    self.frame = CGRectMake(0, 0, 60, 60);
    if (self.georgianWayFoldSlantMalay) {
        [self.correctedView sd_setImageWithURL:[NSURL URLWithString:self.georgianWayFoldSlantMalay] placeholderImage
                                              :[UIImage softnessTableProtectedDisablesChunkyName:AffectedBus.mixProviders.favoritesSnapWhoGallonsGeometry]
                                       options:(SDWebImageDelayPlaceholder)];
    }else {
        self.correctedView.image = self.wetExactHerImage;
    }
    self.correctedView.frame = self.bounds;
    
    [self.fixNoneManWindow addSubview:self];
    [self.fixNoneManWindow addSubview:self.putSubsetView];
}


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

          (positiveLead.size.width - lossy/2),
          positiveLead.size.height - lossy/2,
          lossy,
          lossy
        );
        self.putSubsetView.layer.masksToBounds = YES;
        self.putSubsetView.layer.cornerRadius = lossy/2;
        self.downVowelLabel.center = CGPointMake(lossy/3, lossy/4);
    }
}


- (void)audioMastering {
    if (self.popFairCanJson) {
        !self.goalMathHandler ?: self.goalMathHandler(self.popFairCanJson[AffectedBus.mixProviders.swedishDrum]);
        if ([self.popFairCanJson[AffectedBus.mixProviders.loudHexBondPop] isEqualToString:AffectedBus.mixProviders.updatesMovementPrototypeEncodedAsk]) {
            self.operandOnceView.hidden = YES;
            _popFairCanJson = nil;
        }
    }else {
        !self.goalMathHandler ?: self.goalMathHandler(nil);
    }
}

- (void)moreOrangeMill:(UIPanGestureRecognizer *)gesture {
    if (artistBoundingThickOrderedAppended) return;
        
    CGPoint translation = [gesture translationInView:self.superview];
    
    switch (gesture.state) {
        case UIGestureRecognizerStateBegan:
            zoomTallMixSortComposedStale = self.center;
            _correctedView.alpha = 1;
            [self alienEmbeddingUpdatesPhraseLittle];
            insetRestartHailPinkSmoothingBaltic = NO; 
            irishConsumedFoldActivatedDanish = NO; 
            
            
            [self.layer removeAllAnimations];
            [self.putSubsetView.layer removeAllAnimations];
            
            
            self.putSubsetView.alpha = 0.0;
            self.putSubsetView.transform = CGAffineTransformIdentity;
            break;
            
        case UIGestureRecognizerStateChanged:{
            
            self.center = [self burmeseSeePhrasePluralIdleSolutionsObscuredCenter:
                           CGPointMake(zoomTallMixSortComposedStale.x + translation.x,
                                       zoomTallMixSortComposedStale.y + translation.y)];
            
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
            
            BOOL HalfMathWas = UIInterfaceOrientationIsLandscape([UIApplication sharedApplication].statusBarOrientation);
#pragma clang diagnostic pop
            CGRect zeroFrame = self.putSubsetView.frame;
            CGRect uploadSaw = CGRectInset(zeroFrame, -280, HalfMathWas?-100:-280); 
            BOOL dogCousinTop = CGRectContainsPoint(uploadSaw, self.center);
            
            
            
            
            if (dogCousinTop != irishConsumedFoldActivatedDanish) {
                irishConsumedFoldActivatedDanish = dogCousinTop;
                
                
                [UIView animateWithDuration:0.3
                                      delay:0
                                    options:UIViewAnimationOptionBeginFromCurrentState
                                 animations:^{
                    self.putSubsetView.alpha = dogCousinTop ? 1.0 : 0.0;
                    self.putSubsetView.transform = dogCousinTop ? CGAffineTransformMakeScale(1.2, 1.2) : CGAffineTransformIdentity;
                } completion:nil];
            }
            
            
            dogCousinTop = CGRectContainsPoint(CGRectInset(zeroFrame, 0, 0), self.center);
            if (dogCousinTop && !insetRestartHailPinkSmoothingBaltic) {
                UIImpactFeedbackGenerator *feedback = [[UIImpactFeedbackGenerator alloc] initWithStyle:UIImpactFeedbackStyleMedium];
                [feedback prepare]; 
                [feedback impactOccurred];
                insetRestartHailPinkSmoothingBaltic = YES;
                
                
                [UIView animateWithDuration:0.3
                                      delay:0
                                    options:UIViewAnimationOptionBeginFromCurrentState
                                 animations:^{
                    self.putSubsetView.transform = CGAffineTransformMakeScale(1.3, 1.3);
                } completion:nil];
            } else if (!dogCousinTop) {
                if (insetRestartHailPinkSmoothingBaltic) {
                    self.putSubsetView.transform = CGAffineTransformMakeScale(1.2, 1.2);
                }
                insetRestartHailPinkSmoothingBaltic = NO;
            }
            
            
            uploadSaw = CGRectInset(zeroFrame, 0, 0);
            _defineTexturedWakeAffiliateNordic = CGRectContainsPoint(uploadSaw, self.center);
            break;
        }
            
        case UIGestureRecognizerStateEnded:
        case UIGestureRecognizerStateCancelled: {
            
            [UIView animateWithDuration:0.3 animations:^{
                self.putSubsetView.alpha = 0.0;
                self.putSubsetView.transform = CGAffineTransformIdentity;
            }];
            
            if (_defineTexturedWakeAffiliateNordic) {
                [PutAlertView chromaticFlashSubsetRealmAndAre:nil message:AffectedBus.delayOceanMale.vitaminFrontMagneticCloseDitherHandled poloAllSegue:@[AffectedBus.delayOceanMale.triangleBad, AffectedBus.delayOceanMale.allPink] completion:^(NSInteger binPubIndex) {
                    if (binPubIndex ==1) {
                        [self ornamentsNameScalarInvertSequences];
                    }else {
                        [self sexAbortRenewalRelativeEscapeImmediateAnimation:YES];
                        [self achievedSixteenCanceledTheTriggerTimer];
                    }
                }];
            } else {
                [self sexAbortRenewalRelativeEscapeImmediateAnimation:YES];
                [self achievedSixteenCanceledTheTriggerTimer];
            }
            insetRestartHailPinkSmoothingBaltic = NO;
            irishConsumedFoldActivatedDanish = NO;
            break;
        }

        default: break;
    }
}


- (void)sexAbortRenewalRelativeEscapeImmediateAnimation:(BOOL)animate {
    if (!_warpSaveCarBarAboveIndigo) return;
    
    
    if (artistBoundingThickOrderedAppended && animate) return;
    
    CGRect bankFrame = [self halftoneDownloadsPrepUnlearnButFrame];
    CGPoint center = self.center;
    
    CGFloat film = bankFrame.origin.x;
    CGFloat grow = bankFrame.origin.x + bankFrame.size.width;
    CGFloat hard = bankFrame.origin.y;
    CGFloat arts = bankFrame.origin.y + bankFrame.size.height;
    
    
    SlowHoverWetEdge suffixEdge = TempGarbageTiedLossyChangePair;
    CGFloat bigYoungest = CGFLOAT_MAX;
    
    
    CGFloat hasMid = center.x - film;
    CGFloat capSong = grow - center.x;
    CGFloat offer = center.y - hard;
    CGFloat rightYet = arts - center.y;
    
    NSArray *backupEar = @[@(hasMid), @(capSong), @(offer), @(rightYet)];
    NSArray *edges = @[@(GenericKeepUndoneArmMatrixCompleted), @(ArchivePublicCatRespondsPassivelyFocuses),
                       @(TiedWaxExecutorFocusedMap), @(QuantityIndigoBuddhistLeaseFrontCan)];
    
    for (NSInteger i = 0; i < backupEar.count; i++) {
        CGFloat distance = [backupEar[i] floatValue];
        if (distance < bigYoungest) {
            bigYoungest = distance;
            suffixEdge = [edges[i] integerValue];
        }
    }
    
    
    if (suffixEdge == self.nanogramsCutEdge) {
        CGPoint fixtureCenter = self.center;
        CGPoint detachCenter = [self albumProcedureDeriveStrategyKilobytesOffsetsEdge:suffixEdge];
        CGFloat distance = hypot(fixtureCenter.x - detachCenter.x, fixtureCenter.y - detachCenter.y);
        if (distance < 5.0) { 
            return;
        }
    }
    
    self.nanogramsCutEdge = suffixEdge;
    
    
    CGPoint detachCenter = [self albumProcedureDeriveStrategyKilobytesOffsetsEdge:suffixEdge];
    CGPoint heavyCenter = [self saveStandInvokeFinishBurstEncodingUniversalEdge:suffixEdge];
    
    
    artistBoundingThickOrderedAppended = YES;
    
    
    [CATransaction begin];
    [CATransaction setCompletionBlock:^{
        self->artistBoundingThickOrderedAppended = NO;
    }];
    
    [UIView animateWithDuration:animate ? 0.3 : 0
                     animations:^{
        self.center = detachCenter;
        self.operandOnceView.center = heavyCenter;
    }];
    
    [CATransaction commit];
}


- (CGPoint)albumProcedureDeriveStrategyKilobytesOffsetsEdge:(SlowHoverWetEdge)edge {
    CGRect bankFrame = [self halftoneDownloadsPrepUnlearnButFrame];
    CGPoint center = self.center;
    
    CGFloat film = bankFrame.origin.x;
    CGFloat grow = bankFrame.origin.x + bankFrame.size.width;
    CGFloat hard = bankFrame.origin.y;
    CGFloat arts = bankFrame.origin.y + bankFrame.size.height;
    
    CGPoint detachCenter = center;
    
    switch (edge) {
        case GenericKeepUndoneArmMatrixCompleted:
            detachCenter.x = film + self.bounds.size.width/2 + _parseQueryKind;
            break;
        case ArchivePublicCatRespondsPassivelyFocuses:
            detachCenter.x = grow - self.bounds.size.width/2 - _parseQueryKind;
            break;
        case TiedWaxExecutorFocusedMap:
            detachCenter.y = hard + self.bounds.size.height/2 + _parseQueryKind;
            break;
        case QuantityIndigoBuddhistLeaseFrontCan:
            detachCenter.y = arts - self.bounds.size.height/2 - _parseQueryKind;
            break;
        default:
            break;
    }
    
    
    return [self burmeseSeePhrasePluralIdleSolutionsObscuredCenter:detachCenter];
}


- (CGPoint)saveStandInvokeFinishBurstEncodingUniversalEdge:(SlowHoverWetEdge)edge {
    CGPoint heavyCenter = CGPointMake(0, 0);
    
    switch (edge) {
        case GenericKeepUndoneArmMatrixCompleted:
            heavyCenter.x = self.bounds.size.width;
            break;
        case ArchivePublicCatRespondsPassivelyFocuses:
            
            break;
        case TiedWaxExecutorFocusedMap:
            heavyCenter.x = self.bounds.size.width;
            heavyCenter.y = self.bounds.size.height;
            break;
        case QuantityIndigoBuddhistLeaseFrontCan:
            heavyCenter.x = self.bounds.size.width;
            break;
        default:
            break;
    }
    
    return heavyCenter;
}


- (void)achievedSixteenCanceledTheTriggerTimer {
    if (_expandedFastUtteranceReadableStatic <= 0) return;
    
    [self alienEmbeddingUpdatesPhraseLittle];
    _optimizedOnceTimer = [NSTimer scheduledTimerWithTimeInterval:_expandedFastUtteranceReadableStatic
                                                     target:self
                                                   selector:@selector(returnTooKeepDiscreteAway)
                                                   userInfo:nil
                                                    repeats:NO];
}

- (void)alienEmbeddingUpdatesPhraseLittle {
    [_optimizedOnceTimer invalidate];
    _optimizedOnceTimer = nil;
}

- (void)returnTooKeepDiscreteAway {
    [UIView animateWithDuration:0.3 animations:^{
        self.correctedView.alpha = 0.5;
        
        CGRect frame = self.frame;
        switch (self.nanogramsCutEdge) {
            case GenericKeepUndoneArmMatrixCompleted:
                frame.origin.x -= self.parseQueryKind;
                break;
            case ArchivePublicCatRespondsPassivelyFocuses:
                frame.origin.x += self.parseQueryKind;
                break;
            case TiedWaxExecutorFocusedMap:
                frame.origin.y -= self.parseQueryKind;
                break;
            case QuantityIndigoBuddhistLeaseFrontCan:
                frame.origin.y += self.parseQueryKind;
                break;
            default:
                break;
        }
        self.frame = frame;
    }];
}


- (void)kilowattsExecutingCovariantCursorsCentralUnplugged {
    [self cutoffTouchesSlabCombineChecked];
    [self frictionSelectorLengthFlashUnderageRemoval]; 
    [self sexAbortRenewalRelativeEscapeImmediateAnimation:YES];
}


- (void)cutoffTouchesSlabCombineChecked {
    UIWindow *keyWindow = FutureDryManager.shared.stoodSawTiedWindow; //self.rareLeaseTooWindow;
    UIEdgeInsets safeArea = UIEdgeInsetsZero;
    if (![UIDevice renewRaw]) {
        safeArea = UIEdgeInsetsZero;
    }else if([UIDevice kinYou]) {
        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.connectFisheyeMattingProxyEntries = safeArea;
    self.farTodayStrictlyDayShapePaste = keyWindow.bounds;
}

- (CGRect)halftoneDownloadsPrepUnlearnButFrame {
    
    return CGRectMake(
        self.farTodayStrictlyDayShapePaste.origin.x + self.connectFisheyeMattingProxyEntries.left,
        self.farTodayStrictlyDayShapePaste.origin.y + self.connectFisheyeMattingProxyEntries.top,
        self.farTodayStrictlyDayShapePaste.size.width - (self.connectFisheyeMattingProxyEntries.left + self.connectFisheyeMattingProxyEntries.right),
        self.farTodayStrictlyDayShapePaste.size.height - (self.connectFisheyeMattingProxyEntries.top + self.connectFisheyeMattingProxyEntries.bottom)
    );
}


- (void)coverageFigureSpecifyWindowFlippedWalking {
    NSString *illBadExpert = [[NSUserDefaults standardUserDefaults] valueForKey:AffectedBus.mixProviders.reversingRenewingEitherGrantingArrowInherited];
    if (illBadExpert) {
        self.center = CGPointFromString(illBadExpert);
    }else {
        
        CGRect bankFrame = [self halftoneDownloadsPrepUnlearnButFrame];
        self.center = CGPointMake(bankFrame.origin.x + bankFrame.size.width - self.bounds.size.width/2 - _parseQueryKind,
                                  bankFrame.origin.y + bankFrame.size.height/2);
    }
}


- (UIWindow *)optRectumSliderGuaraniDefaultsWindow {
    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)burmeseSeePhrasePluralIdleSolutionsObscuredCenter:(CGPoint)proposedCenter {
    CGRect bankFrame = [self halftoneDownloadsPrepUnlearnButFrame];
    CGSize buttonSize = self.bounds.size;
    
    CGFloat film = bankFrame.origin.x + buttonSize.width/2;
    CGFloat grow = bankFrame.origin.x + bankFrame.size.width - buttonSize.width/2;
    CGFloat hard = bankFrame.origin.y + buttonSize.height/2;
    CGFloat arts = bankFrame.origin.y + bankFrame.size.height - buttonSize.height/2;
    
    return CGPointMake(
        MAX(film, MIN(proposedCenter.x, grow)),
        MAX(hard, MIN(proposedCenter.y, arts))
    );
}

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

@end