#import "LastDateView.h"
#import "UIImageView+WebCache.h"
#import "UIImage+BagImage.h"
#import "ClaimMaxBig.h"
#import "NSString+Strongest.h"
#import "TwoAlertView.h"
#import "LeadHexWalkCarWindow.h"
#import "MaskEnableBitsViewController.h"
#import "UIDevice+EraDevice.h"
#import "ZoneAngleManager.h"

@interface LastDateView()  <UIGestureRecognizerDelegate> {
    CGPoint attempterNodeBusyRedirectsSingleAppear;
    BOOL argumentsSpecificChargingRandomLigatures;
    BOOL energyLargestFunClosestInlandJob; 
    BOOL tatarChromeUnboundThicknessTurn; 
}


@property (nonatomic, strong) LeadHexWalkCarWindow *lemmaModelWindow;
@property (nonatomic, weak) UIWindow *sexDeviceWaxWindow;


@property (nonatomic, strong) UIImageView *absentItsView;
@property (nonatomic, strong) UIView *factoryTalkView;


@property (nonatomic, strong) UIView *menuArrowView;
@property (nonatomic, strong) UILabel *exposuresLabel;
@property (nonatomic, assign) BOOL faeroeseGuideBookLosePlane;


@property (nonatomic, strong) NSTimer *functionBadgeTimer;
@property (nonatomic, assign) UIEdgeInsets subjectInvokeFarCanGiven;
@property (nonatomic, assign) CGRect spousesWorkspaceNapCompactResultingHow;


@property (nonatomic, strong) UIImage *moireGoogleImage;
@property (nonatomic, copy) NSString *electricHintMaxIronCapable;
@property (nonatomic, strong) UIImage *badmintonImage;
@property (nonatomic, assign) CGFloat notHuePlainSob;
@property (nonatomic, assign) TipPassPowerEdge ageQueryFireEdge;
@property (nonatomic, assign) NSTimeInterval digestDatabasePluralAllowableTrad;
@property (nonatomic, assign) BOOL insideDryAllowableLoveDueDivider;
@end

@implementation LastDateView


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

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

- (void)coulombsMutationsOddGaspNearest {
    self.notHuePlainSob = 10.0;
    self.digestDatabasePluralAllowableTrad = 3.0;
    self.insideDryAllowableLoveDueDivider = YES;
    
    
    self.absentItsView = [[UIImageView alloc] init];
    self.absentItsView.contentMode = UIViewContentModeScaleAspectFit;
    [self addSubview:self.absentItsView];
    
    self.menuArrowView = [[UIView alloc] init];
    self.menuArrowView.backgroundColor = [UIColor colorWithWhite:0 alpha:0.7];
    self.menuArrowView.layer.cornerRadius = 20;
    self.menuArrowView.layer.masksToBounds = YES;
    self.menuArrowView.alpha = 0.0;
    
    self.exposuresLabel = [[UILabel alloc] initWithFrame:CGRectMake(0, 0, 80, 40)];
    self.exposuresLabel.text = ClaimMaxBig.allFeedEarGolf.marginsMalayDemandDismissalCallbacksDirect;
    self.exposuresLabel.numberOfLines = 0;
    self.exposuresLabel.textColor = [UIColor whiteColor];
    self.exposuresLabel.textAlignment = NSTextAlignmentCenter;
    self.exposuresLabel.font = [UIFont systemFontOfSize:14];
    [self.menuArrowView addSubview:self.exposuresLabel];
    
    
    UIPanGestureRecognizer *pan = [[UIPanGestureRecognizer alloc]
                                   initWithTarget:self
                                   action:@selector(markOuncesSelf:)];
    pan.delegate = self;
    [self addGestureRecognizer:pan];
    
    UITapGestureRecognizer *saw = [[UITapGestureRecognizer alloc]
                                   initWithTarget:self
                                   action:@selector(faceLoseLinger)];
    [self addGestureRecognizer:saw];
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
    
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(multipleSubConductorDaughtersCombiningCreated)
                                                 name:UIApplicationDidChangeStatusBarOrientationNotification
                                               object:nil];
#pragma clang diagnostic pop
}

- (void)setPrinterMinJson:(NSDictionary *)printerMinJson {
    _printerMinJson = printerMinJson;
    if (printerMinJson && self.lemmaModelWindow != nil) {
        NSString *action = printerMinJson[ClaimMaxBig.applierPatch.managedComplex];
        if ([action isEqualToString:ClaimMaxBig.applierPatch.planePortEnd]) {
            self.factoryTalkView.hidden = NO;
        }else if ([action isEqualToString:ClaimMaxBig.applierPatch.bleedCiphers]) {
            self.factoryTalkView.hidden = YES;
        }else if ([action isEqualToString:ClaimMaxBig.applierPatch.ageAgentConcertAtomKilowatt]) {
            self.factoryTalkView.hidden = NO;
        }
    }
}


+ (void)currently {
    [self.shared preventsCenterCaptionPerfusionEscapingCapImage:[UIImage earResumeRawOwnFatName:ClaimMaxBig.applierPatch.smoothedDueResourceActionCompile] primeEra:ClaimMaxBig.axesOwnKazakhHasSentence headImage:nil];
}

+ (void)legacyPrivacyImage:(UIImage *)image {
    [[self shared] preventsCenterCaptionPerfusionEscapingCapImage:image headImage:nil];
}

+ (void)flagSayFileImage:(UIImage *)normalImage headImage:(nullable UIImage *)headImage {
    LastDateView *instance = [self shared];
    instance.moireGoogleImage = normalImage;
    instance.electricHintMaxIronCapable = nil;
    instance.badmintonImage = headImage;
    instance.absentItsView.image = normalImage;
}

+ (void)standHave {
    [[self shared] cutterForAgeMaskTarget];
}

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


- (void)preventsCenterCaptionPerfusionEscapingCapImage:(UIImage *)image headImage:(nullable UIImage *)headImage {
    [self preventsCenterCaptionPerfusionEscapingCapImage:image primeEra:nil headImage:headImage];
}

- (void)preventsCenterCaptionPerfusionEscapingCapImage:(UIImage *)image primeEra:(NSString *)primeEra headImage:(nullable UIImage *)headImage {
    dispatch_async(dispatch_get_main_queue(), ^{
        self.moireGoogleImage = image;
        self.electricHintMaxIronCapable = primeEra;
        self.badmintonImage = headImage;
        
        if (!self.lemmaModelWindow) {
            [self exactMalteseTamilHisYouWindow];
            [self firstBarriersLuminanceRoleCroatian];
            [self resonantEndpointDigitizedChromiumStartedAttached];
            [self toggleMegawattsPotentialPutMultipleAdvance]; 
        }
        
        [self.lemmaModelWindow makeKeyAndVisible];
        [self.sexDeviceWaxWindow makeKeyWindow];
        
        [self roomFlowProducedTrademarkRectumReportedAnimation:YES];
        [self producingEncryptCatBookmarksModuleTimer];
    });
}

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


- (void)exactMalteseTamilHisYouWindow {
    
    self.sexDeviceWaxWindow = [self catStationEggSevenClippingWindow];
    
    
    LeadHexWalkCarWindow *window = nil;
    
    
    if (@available(iOS 13.0, *)) {
        for (UIScene *scene in [UIApplication sharedApplication].connectedScenes) {
            if (scene.activationState == UISceneActivationStateForegroundActive &&
                [scene isKindOfClass:[UIWindowScene class]]) {
                window = [[LeadHexWalkCarWindow alloc] initWithWindowScene:(UIWindowScene *)scene];
                break;
            }
        }
    }
    
    
    if (!window) {
        window = [[LeadHexWalkCarWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];
    }
    
    
    window.backgroundColor = [UIColor clearColor];
    window.clipsToBounds = YES; 
    window.windowLevel = UIWindowLevelAlert + 1000;
    window.backgroundColor = [UIColor clearColor];
    window.rootViewController = [[MaskEnableBitsViewController alloc] init];
    window.hidden = NO;
    self.lemmaModelWindow = window;
    
    
    [self.lemmaModelWindow resignKeyWindow];
    [self.sexDeviceWaxWindow makeKeyWindow];
    
    
    [self addSubview:self.factoryTalkView];
    
    
    self.frame = CGRectMake(0, 0, 60, 60);
    if (self.electricHintMaxIronCapable) {
        [self.absentItsView sd_setImageWithURL:[NSURL URLWithString:self.electricHintMaxIronCapable] placeholderImage
                                              :[UIImage earResumeRawOwnFatName:ClaimMaxBig.applierPatch.smoothedDueResourceActionCompile]
                                       options:(SDWebImageDelayPlaceholder)];
    }else {
        self.absentItsView.image = self.moireGoogleImage;
    }
    self.absentItsView.frame = self.bounds;
    
    [self.lemmaModelWindow addSubview:self];
    [self.lemmaModelWindow addSubview:self.menuArrowView];
}


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

          (weekTraining.size.width - inner/2),
          weekTraining.size.height - inner/2,
          inner,
          inner
        );
        self.menuArrowView.layer.masksToBounds = YES;
        self.menuArrowView.layer.cornerRadius = inner/2;
        self.exposuresLabel.center = CGPointMake(inner/3, inner/4);
    }
}


- (void)faceLoseLinger {
    if (self.printerMinJson) {
        !self.queryEarHandler ?: self.queryEarHandler(self.printerMinJson[ClaimMaxBig.applierPatch.bikeChamber]);
        if ([self.printerMinJson[ClaimMaxBig.applierPatch.managedComplex] isEqualToString:ClaimMaxBig.applierPatch.ageAgentConcertAtomKilowatt]) {
            self.factoryTalkView.hidden = YES;
            _printerMinJson = nil;
        }
    }else {
        !self.queryEarHandler ?: self.queryEarHandler(nil);
    }
}

- (void)markOuncesSelf:(UIPanGestureRecognizer *)gesture {
    if (argumentsSpecificChargingRandomLigatures) return;
        
    CGPoint translation = [gesture translationInView:self.superview];
    
    switch (gesture.state) {
        case UIGestureRecognizerStateBegan:
            attempterNodeBusyRedirectsSingleAppear = self.center;
            _absentItsView.alpha = 1;
            [self zipInstantYearsDriveBridge];
            energyLargestFunClosestInlandJob = NO; 
            tatarChromeUnboundThicknessTurn = NO; 
            
            
            [self.layer removeAllAnimations];
            [self.menuArrowView.layer removeAllAnimations];
            
            
            self.menuArrowView.alpha = 0.0;
            self.menuArrowView.transform = CGAffineTransformIdentity;
            break;
            
        case UIGestureRecognizerStateChanged:{
            
            self.center = [self mightMoodLifetimeOppositeNoticeInferiorsReportCenter:
                           CGPointMake(attempterNodeBusyRedirectsSingleAppear.x + translation.x,
                                       attempterNodeBusyRedirectsSingleAppear.y + translation.y)];
            
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
            
            BOOL BusPushKeys = UIInterfaceOrientationIsLandscape([UIApplication sharedApplication].statusBarOrientation);
#pragma clang diagnostic pop
            CGRect endsFrame = self.menuArrowView.frame;
            CGRect chargeOff = CGRectInset(endsFrame, -280, BusPushKeys?-100:-280); 
            BOOL positionsDue = CGRectContainsPoint(chargeOff, self.center);
            
            
            
            
            if (positionsDue != tatarChromeUnboundThicknessTurn) {
                tatarChromeUnboundThicknessTurn = positionsDue;
                
                
                [UIView animateWithDuration:0.3
                                      delay:0
                                    options:UIViewAnimationOptionBeginFromCurrentState
                                 animations:^{
                    self.menuArrowView.alpha = positionsDue ? 1.0 : 0.0;
                    self.menuArrowView.transform = positionsDue ? CGAffineTransformMakeScale(1.2, 1.2) : CGAffineTransformIdentity;
                } completion:nil];
            }
            
            
            positionsDue = CGRectContainsPoint(CGRectInset(endsFrame, 0, 0), self.center);
            if (positionsDue && !energyLargestFunClosestInlandJob) {
                UIImpactFeedbackGenerator *feedback = [[UIImpactFeedbackGenerator alloc] initWithStyle:UIImpactFeedbackStyleMedium];
                [feedback prepare]; 
                [feedback impactOccurred];
                energyLargestFunClosestInlandJob = YES;
                
                
                [UIView animateWithDuration:0.3
                                      delay:0
                                    options:UIViewAnimationOptionBeginFromCurrentState
                                 animations:^{
                    self.menuArrowView.transform = CGAffineTransformMakeScale(1.3, 1.3);
                } completion:nil];
            } else if (!positionsDue) {
                if (energyLargestFunClosestInlandJob) {
                    self.menuArrowView.transform = CGAffineTransformMakeScale(1.2, 1.2);
                }
                energyLargestFunClosestInlandJob = NO;
            }
            
            
            chargeOff = CGRectInset(endsFrame, 0, 0);
            _faeroeseGuideBookLosePlane = CGRectContainsPoint(chargeOff, self.center);
            break;
        }
            
        case UIGestureRecognizerStateEnded:
        case UIGestureRecognizerStateCancelled: {
            
            [UIView animateWithDuration:0.3 animations:^{
                self.menuArrowView.alpha = 0.0;
                self.menuArrowView.transform = CGAffineTransformIdentity;
            }];
            
            if (_faeroeseGuideBookLosePlane) {
                [TwoAlertView oldDomainsDesignerSeeThreeAccurate:nil message:ClaimMaxBig.allFeedEarGolf.metalFlexibleEvaluatedPerformsCompileBorder oneBusPreset:@[ClaimMaxBig.allFeedEarGolf.safeLogWire, ClaimMaxBig.allFeedEarGolf.fatMove] completion:^(NSInteger shrinkIndex) {
                    if (shrinkIndex ==1) {
                        [self cutterForAgeMaskTarget];
                    }else {
                        [self roomFlowProducedTrademarkRectumReportedAnimation:YES];
                        [self producingEncryptCatBookmarksModuleTimer];
                    }
                }];
            } else {
                [self roomFlowProducedTrademarkRectumReportedAnimation:YES];
                [self producingEncryptCatBookmarksModuleTimer];
            }
            energyLargestFunClosestInlandJob = NO;
            tatarChromeUnboundThicknessTurn = NO;
            break;
        }

        default: break;
    }
}


- (void)roomFlowProducedTrademarkRectumReportedAnimation:(BOOL)animate {
    if (!_insideDryAllowableLoveDueDivider) return;
    
    
    if (argumentsSpecificChargingRandomLigatures && animate) return;
    
    CGRect pathFrame = [self strokingAcquireAdjectiveGaspCopticFrame];
    CGPoint center = self.center;
    
    CGFloat foot = pathFrame.origin.x;
    CGFloat tall = pathFrame.origin.x + pathFrame.size.width;
    CGFloat leap = pathFrame.origin.y;
    CGFloat best = pathFrame.origin.y + pathFrame.size.height;
    
    
    TipPassPowerEdge minBusEdge = RecordingDecisionCaseFactoryMandarinDeliver;
    CGFloat outSinDolby = CGFLOAT_MAX;
    
    
    CGFloat absent = center.x - foot;
    CGFloat lexical = tall - center.x;
    CGFloat avail = center.y - leap;
    CGFloat sexMedia = best - center.y;
    
    NSArray *fiveBlend = @[@(absent), @(lexical), @(avail), @(sexMedia)];
    NSArray *edges = @[@(EventPinSparseTorchPerformerTransient), @(OverwriteFitDryRejectionIncreaseInvitee),
                       @(RouterVeryRejectionReasonArts), @(UnwrapPeriodDeferringAreaPrologSalient)];
    
    for (NSInteger i = 0; i < fiveBlend.count; i++) {
        CGFloat distance = [fiveBlend[i] floatValue];
        if (distance < outSinDolby) {
            outSinDolby = distance;
            minBusEdge = [edges[i] integerValue];
        }
    }
    
    
    if (minBusEdge == self.ageQueryFireEdge) {
        CGPoint printedCenter = self.center;
        CGPoint reduceCenter = [self symbolFarsiSixteenWonSockBounceEdge:minBusEdge];
        CGFloat distance = hypot(printedCenter.x - reduceCenter.x, printedCenter.y - reduceCenter.y);
        if (distance < 5.0) { 
            return;
        }
    }
    
    self.ageQueryFireEdge = minBusEdge;
    
    
    CGPoint reduceCenter = [self symbolFarsiSixteenWonSockBounceEdge:minBusEdge];
    CGPoint alertCenter = [self runWidgetTranslateTransposePenModuleNotEdge:minBusEdge];
    
    
    argumentsSpecificChargingRandomLigatures = YES;
    
    
    [CATransaction begin];
    [CATransaction setCompletionBlock:^{
        self->argumentsSpecificChargingRandomLigatures = NO;
    }];
    
    [UIView animateWithDuration:animate ? 0.3 : 0
                     animations:^{
        self.center = reduceCenter;
        self.factoryTalkView.center = alertCenter;
    }];
    
    [CATransaction commit];
}


- (CGPoint)symbolFarsiSixteenWonSockBounceEdge:(TipPassPowerEdge)edge {
    CGRect pathFrame = [self strokingAcquireAdjectiveGaspCopticFrame];
    CGPoint center = self.center;
    
    CGFloat foot = pathFrame.origin.x;
    CGFloat tall = pathFrame.origin.x + pathFrame.size.width;
    CGFloat leap = pathFrame.origin.y;
    CGFloat best = pathFrame.origin.y + pathFrame.size.height;
    
    CGPoint reduceCenter = center;
    
    switch (edge) {
        case EventPinSparseTorchPerformerTransient:
            reduceCenter.x = foot + self.bounds.size.width/2 + _notHuePlainSob;
            break;
        case OverwriteFitDryRejectionIncreaseInvitee:
            reduceCenter.x = tall - self.bounds.size.width/2 - _notHuePlainSob;
            break;
        case RouterVeryRejectionReasonArts:
            reduceCenter.y = leap + self.bounds.size.height/2 + _notHuePlainSob;
            break;
        case UnwrapPeriodDeferringAreaPrologSalient:
            reduceCenter.y = best - self.bounds.size.height/2 - _notHuePlainSob;
            break;
        default:
            break;
    }
    
    
    return [self mightMoodLifetimeOppositeNoticeInferiorsReportCenter:reduceCenter];
}


- (CGPoint)runWidgetTranslateTransposePenModuleNotEdge:(TipPassPowerEdge)edge {
    CGPoint alertCenter = CGPointMake(0, 0);
    
    switch (edge) {
        case EventPinSparseTorchPerformerTransient:
            alertCenter.x = self.bounds.size.width;
            break;
        case OverwriteFitDryRejectionIncreaseInvitee:
            
            break;
        case RouterVeryRejectionReasonArts:
            alertCenter.x = self.bounds.size.width;
            alertCenter.y = self.bounds.size.height;
            break;
        case UnwrapPeriodDeferringAreaPrologSalient:
            alertCenter.x = self.bounds.size.width;
            break;
        default:
            break;
    }
    
    return alertCenter;
}


- (void)producingEncryptCatBookmarksModuleTimer {
    if (_digestDatabasePluralAllowableTrad <= 0) return;
    
    [self zipInstantYearsDriveBridge];
    _functionBadgeTimer = [NSTimer scheduledTimerWithTimeInterval:_digestDatabasePluralAllowableTrad
                                                     target:self
                                                   selector:@selector(metabolicBendPricePhraseMajor)
                                                   userInfo:nil
                                                    repeats:NO];
}

- (void)zipInstantYearsDriveBridge {
    [_functionBadgeTimer invalidate];
    _functionBadgeTimer = nil;
}

- (void)metabolicBendPricePhraseMajor {
    [UIView animateWithDuration:0.3 animations:^{
        self.absentItsView.alpha = 0.5;
        
        CGRect frame = self.frame;
        switch (self.ageQueryFireEdge) {
            case EventPinSparseTorchPerformerTransient:
                frame.origin.x -= self.notHuePlainSob;
                break;
            case OverwriteFitDryRejectionIncreaseInvitee:
                frame.origin.x += self.notHuePlainSob;
                break;
            case RouterVeryRejectionReasonArts:
                frame.origin.y -= self.notHuePlainSob;
                break;
            case UnwrapPeriodDeferringAreaPrologSalient:
                frame.origin.y += self.notHuePlainSob;
                break;
            default:
                break;
        }
        self.frame = frame;
    }];
}


- (void)multipleSubConductorDaughtersCombiningCreated {
    [self firstBarriersLuminanceRoleCroatian];
    [self toggleMegawattsPotentialPutMultipleAdvance]; 
    [self roomFlowProducedTrademarkRectumReportedAnimation:YES];
}


- (void)firstBarriersLuminanceRoleCroatian {
    UIWindow *keyWindow = ZoneAngleManager.shared.retGigabytesWindow; //self.sexDeviceWaxWindow;
    UIEdgeInsets safeArea = UIEdgeInsetsZero;
    if (![UIDevice underEar]) {
        safeArea = UIEdgeInsetsZero;
    }else if([UIDevice seeTop]) {
        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.subjectInvokeFarCanGiven = safeArea;
    self.spousesWorkspaceNapCompactResultingHow = keyWindow.bounds;
}

- (CGRect)strokingAcquireAdjectiveGaspCopticFrame {
    
    return CGRectMake(
        self.spousesWorkspaceNapCompactResultingHow.origin.x + self.subjectInvokeFarCanGiven.left,
        self.spousesWorkspaceNapCompactResultingHow.origin.y + self.subjectInvokeFarCanGiven.top,
        self.spousesWorkspaceNapCompactResultingHow.size.width - (self.subjectInvokeFarCanGiven.left + self.subjectInvokeFarCanGiven.right),
        self.spousesWorkspaceNapCompactResultingHow.size.height - (self.subjectInvokeFarCanGiven.top + self.subjectInvokeFarCanGiven.bottom)
    );
}


- (void)resonantEndpointDigitizedChromiumStartedAttached {
    NSString *heapAreMicro = [[NSUserDefaults standardUserDefaults] valueForKey:ClaimMaxBig.applierPatch.downhillGoogleSawNetCelsiusHalf];
    if (heapAreMicro) {
        self.center = CGPointFromString(heapAreMicro);
    }else {
        
        CGRect pathFrame = [self strokingAcquireAdjectiveGaspCopticFrame];
        self.center = CGPointMake(pathFrame.origin.x + pathFrame.size.width - self.bounds.size.width/2 - _notHuePlainSob,
                                  pathFrame.origin.y + pathFrame.size.height/2);
    }
}


- (UIWindow *)catStationEggSevenClippingWindow {
    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)mightMoodLifetimeOppositeNoticeInferiorsReportCenter:(CGPoint)proposedCenter {
    CGRect pathFrame = [self strokingAcquireAdjectiveGaspCopticFrame];
    CGSize buttonSize = self.bounds.size;
    
    CGFloat foot = pathFrame.origin.x + buttonSize.width/2;
    CGFloat tall = pathFrame.origin.x + pathFrame.size.width - buttonSize.width/2;
    CGFloat leap = pathFrame.origin.y + buttonSize.height/2;
    CGFloat best = pathFrame.origin.y + pathFrame.size.height - buttonSize.height/2;
    
    return CGPointMake(
        MAX(foot, MIN(proposedCenter.x, tall)),
        MAX(leap, MIN(proposedCenter.y, best))
    );
}

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

@end