#import "ComparedView.h"
#import "UIImageView+WebCache.h"
#import "UIImage+BagImage.h"
#import "HexDiscrete.h"
#import "NSString+RoleBreak.h"
#import "BadAlertView.h"
#import "ScriptsHellmanWindow.h"
#import "RaiseUseMaxNetViewController.h"
#import "UIDevice+SumDevice.h"
#import "SoloSlantManager.h"

@interface ComparedView()  <UIGestureRecognizerDelegate> {
    CGPoint emergencyHalftoneRootStaticStreamedStructure;
    BOOL catQualifiedOrnamentNodeMid;
    BOOL treeSaturatedPrefersExposureLambdaView; 
    BOOL texturedManyOrderPredicateWait; 
}


@property (nonatomic, strong) ScriptsHellmanWindow *hostToggleWindow;
@property (nonatomic, weak) UIWindow *stereoSyntaxWindow;


@property (nonatomic, strong) UIImageView *jobUplinkView;
@property (nonatomic, strong) UIView *guestRecordView;


@property (nonatomic, strong) UIView *aboveBikeView;
@property (nonatomic, strong) UILabel *darkStaleLabel;
@property (nonatomic, assign) BOOL graphicsIronTriggeredPasswordsDigitized;


@property (nonatomic, strong) NSTimer *fisheyeSphereTimer;
@property (nonatomic, assign) UIEdgeInsets performsNeedPunjabiEncryptedSob;
@property (nonatomic, assign) CGRect followerExclusionTriangleHerSpecificRound;


@property (nonatomic, strong) UIImage *eyeRawVoiceImage;
@property (nonatomic, copy) NSString *holdStandMegahertzHeaderMight;
@property (nonatomic, strong) UIImage *lookupBoxImage;
@property (nonatomic, assign) CGFloat tagPushOffDrop;
@property (nonatomic, assign) ClockSettingEdge catCompositeEdge;
@property (nonatomic, assign) NSTimeInterval redDownhillRangingCommentOpt;
@property (nonatomic, assign) BOOL adoptOptionalRedPhraseActionsBorder;
@end

@implementation ComparedView


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

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

- (void)cornersConjugateOurUrgentStructure {
    self.tagPushOffDrop = 10.0;
    self.redDownhillRangingCommentOpt = 3.0;
    self.adoptOptionalRedPhraseActionsBorder = YES;
    
    
    self.jobUplinkView = [[UIImageView alloc] init];
    self.jobUplinkView.contentMode = UIViewContentModeScaleAspectFit;
    [self addSubview:self.jobUplinkView];
    
    self.aboveBikeView = [[UIView alloc] init];
    self.aboveBikeView.backgroundColor = [UIColor colorWithWhite:0 alpha:0.7];
    self.aboveBikeView.layer.cornerRadius = 20;
    self.aboveBikeView.layer.masksToBounds = YES;
    self.aboveBikeView.alpha = 0.0;
    
    self.darkStaleLabel = [[UILabel alloc] initWithFrame:CGRectMake(0, 0, 80, 40)];
    self.darkStaleLabel.text = HexDiscrete.twistSheWasWin.verifyWritingBothDrawAffineWorld;
    self.darkStaleLabel.numberOfLines = 0;
    self.darkStaleLabel.textColor = [UIColor whiteColor];
    self.darkStaleLabel.textAlignment = NSTextAlignmentCenter;
    self.darkStaleLabel.font = [UIFont systemFontOfSize:14];
    [self.aboveBikeView addSubview:self.darkStaleLabel];
    
    
    UIPanGestureRecognizer *pan = [[UIPanGestureRecognizer alloc]
                                   initWithTarget:self
                                   action:@selector(tallLikeHeight:)];
    pan.delegate = self;
    [self addGestureRecognizer:pan];
    
    UITapGestureRecognizer *own = [[UITapGestureRecognizer alloc]
                                   initWithTarget:self
                                   action:@selector(hitPinRoomJust)];
    [self addGestureRecognizer:own];
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
    
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(inverseAlertMirroredEvaluatedUndoAny)
                                                 name:UIApplicationDidChangeStatusBarOrientationNotification
                                               object:nil];
#pragma clang diagnostic pop
}

- (void)setMoodTorqueJson:(NSDictionary *)moodTorqueJson {
    _moodTorqueJson = moodTorqueJson;
    if (moodTorqueJson && self.hostToggleWindow != nil) {
        NSString *action = moodTorqueJson[HexDiscrete.shelfTenSide.iconEndsAsleep];
        if ([action isEqualToString:HexDiscrete.shelfTenSide.ownNumerator]) {
            self.guestRecordView.hidden = NO;
        }else if ([action isEqualToString:HexDiscrete.shelfTenSide.floorDayZero]) {
            self.guestRecordView.hidden = YES;
        }else if ([action isEqualToString:HexDiscrete.shelfTenSide.hexThickGolfPluralUpdating]) {
            self.guestRecordView.hidden = NO;
        }
    }
}


+ (void)arrayMail {
    [self.shared reloadContainedTipBrokenExtrinsicTrailingImage:[UIImage hebrewLostLengthKeysLegacyName:HexDiscrete.shelfTenSide.rejectMixFarsiDirectMeal] manMount:HexDiscrete.subtitlePeopleSentReachableLifetime hardImage:nil];
}

+ (void)youSumEggTintImage:(UIImage *)image {
    [[self shared] reloadContainedTipBrokenExtrinsicTrailingImage:image hardImage:nil];
}

+ (void)operatorCutImage:(UIImage *)normalImage hardImage:(nullable UIImage *)hardImage {
    ComparedView *instance = [self shared];
    instance.eyeRawVoiceImage = normalImage;
    instance.holdStandMegahertzHeaderMight = nil;
    instance.lookupBoxImage = hardImage;
    instance.jobUplinkView.image = normalImage;
}

+ (void)dublinBut {
    [[self shared] penUniformAscendingAnyRetried];
}

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


- (void)reloadContainedTipBrokenExtrinsicTrailingImage:(UIImage *)image hardImage:(nullable UIImage *)hardImage {
    [self reloadContainedTipBrokenExtrinsicTrailingImage:image manMount:nil hardImage:hardImage];
}

- (void)reloadContainedTipBrokenExtrinsicTrailingImage:(UIImage *)image manMount:(NSString *)manMount hardImage:(nullable UIImage *)hardImage {
    dispatch_async(dispatch_get_main_queue(), ^{
        self.eyeRawVoiceImage = image;
        self.holdStandMegahertzHeaderMight = manMount;
        self.lookupBoxImage = hardImage;
        
        if (!self.hostToggleWindow) {
            [self neverAdvancedFirmwareCampaignShortcutsWindow];
            [self nothingMasterLeftStepsonCentering];
            [self slightMalformedPrologPhoneticExtentsLuminance];
            [self friendWorkLoadGermanExtentWritten]; 
        }
        
        [self.hostToggleWindow makeKeyAndVisible];
        [self.stereoSyntaxWindow makeKeyWindow];
        
        [self surrogateRejectUtilitiesAggregateAlertBeginAnimation:YES];
        [self directoryBurstFollowZeroWeekendTimer];
    });
}

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


- (void)neverAdvancedFirmwareCampaignShortcutsWindow {
    
    self.stereoSyntaxWindow = [self mayComposerPositiveQuechuaPencilWindow];
    
    
    ScriptsHellmanWindow *window = nil;
    
    
    if (@available(iOS 13.0, *)) {
        for (UIScene *scene in [UIApplication sharedApplication].connectedScenes) {
            if (scene.activationState == UISceneActivationStateForegroundActive &&
                [scene isKindOfClass:[UIWindowScene class]]) {
                window = [[ScriptsHellmanWindow alloc] initWithWindowScene:(UIWindowScene *)scene];
                break;
            }
        }
    }
    
    
    if (!window) {
        window = [[ScriptsHellmanWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];
    }
    
    
    window.backgroundColor = [UIColor clearColor];
    window.clipsToBounds = YES; 
    window.windowLevel = UIWindowLevelAlert + 1000;
    window.backgroundColor = [UIColor clearColor];
    window.rootViewController = [[RaiseUseMaxNetViewController alloc] init];
    window.hidden = NO;
    self.hostToggleWindow = window;
    
    
    [self.hostToggleWindow resignKeyWindow];
    [self.stereoSyntaxWindow makeKeyWindow];
    
    
    [self addSubview:self.guestRecordView];
    
    
    self.frame = CGRectMake(0, 0, 60, 60);
    if (self.holdStandMegahertzHeaderMight) {
        [self.jobUplinkView sd_setImageWithURL:[NSURL URLWithString:self.holdStandMegahertzHeaderMight] placeholderImage
                                              :[UIImage hebrewLostLengthKeysLegacyName:HexDiscrete.shelfTenSide.rejectMixFarsiDirectMeal]
                                       options:(SDWebImageDelayPlaceholder)];
    }else {
        self.jobUplinkView.image = self.eyeRawVoiceImage;
    }
    self.jobUplinkView.frame = self.bounds;
    
    [self.hostToggleWindow addSubview:self];
    [self.hostToggleWindow addSubview:self.aboveBikeView];
}


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

          (defaultsIdle.size.width - space/2),
          defaultsIdle.size.height - space/2,
          space,
          space
        );
        self.aboveBikeView.layer.masksToBounds = YES;
        self.aboveBikeView.layer.cornerRadius = space/2;
        self.darkStaleLabel.center = CGPointMake(space/3, space/4);
    }
}


- (void)hitPinRoomJust {
    if (self.moodTorqueJson) {
        !self.hitSheetHandler ?: self.hitSheetHandler(self.moodTorqueJson[HexDiscrete.shelfTenSide.hasBoxTouch]);
        if ([self.moodTorqueJson[HexDiscrete.shelfTenSide.iconEndsAsleep] isEqualToString:HexDiscrete.shelfTenSide.hexThickGolfPluralUpdating]) {
            self.guestRecordView.hidden = YES;
            _moodTorqueJson = nil;
        }
    }else {
        !self.hitSheetHandler ?: self.hitSheetHandler(nil);
    }
}

- (void)tallLikeHeight:(UIPanGestureRecognizer *)gesture {
    if (catQualifiedOrnamentNodeMid) return;
        
    CGPoint translation = [gesture translationInView:self.superview];
    
    switch (gesture.state) {
        case UIGestureRecognizerStateBegan:
            emergencyHalftoneRootStaticStreamedStructure = self.center;
            _jobUplinkView.alpha = 1;
            [self fixExtrasColorSaturatedDrum];
            treeSaturatedPrefersExposureLambdaView = NO; 
            texturedManyOrderPredicateWait = NO; 
            
            
            [self.layer removeAllAnimations];
            [self.aboveBikeView.layer removeAllAnimations];
            
            
            self.aboveBikeView.alpha = 0.0;
            self.aboveBikeView.transform = CGAffineTransformIdentity;
            break;
            
        case UIGestureRecognizerStateChanged:{
            
            self.center = [self assumeTriggerBinCustodianSecondaryCupIndicatorCenter:
                           CGPointMake(emergencyHalftoneRootStaticStreamedStructure.x + translation.x,
                                       emergencyHalftoneRootStaticStreamedStructure.y + translation.y)];
            
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
            
            BOOL IllTatarLog = UIInterfaceOrientationIsLandscape([UIApplication sharedApplication].statusBarOrientation);
#pragma clang diagnostic pop
            CGRect cubeFrame = self.aboveBikeView.frame;
            CGRect beaconLow = CGRectInset(cubeFrame, -280, IllTatarLog?-100:-280); 
            BOOL noteAssetTag = CGRectContainsPoint(beaconLow, self.center);
            
            
            
            
            if (noteAssetTag != texturedManyOrderPredicateWait) {
                texturedManyOrderPredicateWait = noteAssetTag;
                
                
                [UIView animateWithDuration:0.3
                                      delay:0
                                    options:UIViewAnimationOptionBeginFromCurrentState
                                 animations:^{
                    self.aboveBikeView.alpha = noteAssetTag ? 1.0 : 0.0;
                    self.aboveBikeView.transform = noteAssetTag ? CGAffineTransformMakeScale(1.2, 1.2) : CGAffineTransformIdentity;
                } completion:nil];
            }
            
            
            noteAssetTag = CGRectContainsPoint(CGRectInset(cubeFrame, 0, 0), self.center);
            if (noteAssetTag && !treeSaturatedPrefersExposureLambdaView) {
                UIImpactFeedbackGenerator *feedback = [[UIImpactFeedbackGenerator alloc] initWithStyle:UIImpactFeedbackStyleMedium];
                [feedback prepare]; 
                [feedback impactOccurred];
                treeSaturatedPrefersExposureLambdaView = YES;
                
                
                [UIView animateWithDuration:0.3
                                      delay:0
                                    options:UIViewAnimationOptionBeginFromCurrentState
                                 animations:^{
                    self.aboveBikeView.transform = CGAffineTransformMakeScale(1.3, 1.3);
                } completion:nil];
            } else if (!noteAssetTag) {
                if (treeSaturatedPrefersExposureLambdaView) {
                    self.aboveBikeView.transform = CGAffineTransformMakeScale(1.2, 1.2);
                }
                treeSaturatedPrefersExposureLambdaView = NO;
            }
            
            
            beaconLow = CGRectInset(cubeFrame, 0, 0);
            _graphicsIronTriggeredPasswordsDigitized = CGRectContainsPoint(beaconLow, self.center);
            break;
        }
            
        case UIGestureRecognizerStateEnded:
        case UIGestureRecognizerStateCancelled: {
            
            [UIView animateWithDuration:0.3 animations:^{
                self.aboveBikeView.alpha = 0.0;
                self.aboveBikeView.transform = CGAffineTransformIdentity;
            }];
            
            if (_graphicsIronTriggeredPasswordsDigitized) {
                [BadAlertView oddDepthCanUseTipWaist:nil message:HexDiscrete.twistSheWasWin.audibleSubmitNoteFirmwareLossEnd armpitArtUse:@[HexDiscrete.twistSheWasWin.blobBagCity, HexDiscrete.twistSheWasWin.tipPlug] completion:^(NSInteger hasSayIndex) {
                    if (hasSayIndex ==1) {
                        [self penUniformAscendingAnyRetried];
                    }else {
                        [self surrogateRejectUtilitiesAggregateAlertBeginAnimation:YES];
                        [self directoryBurstFollowZeroWeekendTimer];
                    }
                }];
            } else {
                [self surrogateRejectUtilitiesAggregateAlertBeginAnimation:YES];
                [self directoryBurstFollowZeroWeekendTimer];
            }
            treeSaturatedPrefersExposureLambdaView = NO;
            texturedManyOrderPredicateWait = NO;
            break;
        }

        default: break;
    }
}


- (void)surrogateRejectUtilitiesAggregateAlertBeginAnimation:(BOOL)animate {
    if (!_adoptOptionalRedPhraseActionsBorder) return;
    
    
    if (catQualifiedOrnamentNodeMid && animate) return;
    
    CGRect fullFrame = [self patchRetLocalesStakeIntentFrame];
    CGPoint center = self.center;
    
    CGFloat past = fullFrame.origin.x;
    CGFloat food = fullFrame.origin.x + fullFrame.size.width;
    CGFloat sink = fullFrame.origin.y;
    CGFloat half = fullFrame.origin.y + fullFrame.size.height;
    
    
    ClockSettingEdge sawOptEdge = CategoryStepsonDelayedFloatingLocalQuery;
    CGFloat issueFiller = CGFLOAT_MAX;
    
    
    CGFloat effort = center.x - past;
    CGFloat notDown = food - center.x;
    CGFloat chunk = center.y - sink;
    CGFloat arrowPut = half - center.y;
    
    NSArray *localeNow = @[@(effort), @(notDown), @(chunk), @(arrowPut)];
    NSArray *edges = @[@(DailyLiveTextRowDidExceeds), @(LayoutStrokedSensorStaticTwitterAspect),
                       @(MinSobSnapConfigureFold), @(SayLargeInitiallyPrintedTheLong)];
    
    for (NSInteger i = 0; i < localeNow.count; i++) {
        CGFloat distance = [localeNow[i] floatValue];
        if (distance < issueFiller) {
            issueFiller = distance;
            sawOptEdge = [edges[i] integerValue];
        }
    }
    
    
    if (sawOptEdge == self.catCompositeEdge) {
        CGPoint grantedCenter = self.center;
        CGPoint originCenter = [self seedThumbnailEffortWorkRepeatEraEdge:sawOptEdge];
        CGFloat distance = hypot(grantedCenter.x - originCenter.x, grantedCenter.y - originCenter.y);
        if (distance < 5.0) { 
            return;
        }
    }
    
    self.catCompositeEdge = sawOptEdge;
    
    
    CGPoint originCenter = [self seedThumbnailEffortWorkRepeatEraEdge:sawOptEdge];
    CGPoint alignCenter = [self rowCutoffSomaliHoverDanishReachedPhotosEdge:sawOptEdge];
    
    
    catQualifiedOrnamentNodeMid = YES;
    
    
    [CATransaction begin];
    [CATransaction setCompletionBlock:^{
        self->catQualifiedOrnamentNodeMid = NO;
    }];
    
    [UIView animateWithDuration:animate ? 0.3 : 0
                     animations:^{
        self.center = originCenter;
        self.guestRecordView.center = alignCenter;
    }];
    
    [CATransaction commit];
}


- (CGPoint)seedThumbnailEffortWorkRepeatEraEdge:(ClockSettingEdge)edge {
    CGRect fullFrame = [self patchRetLocalesStakeIntentFrame];
    CGPoint center = self.center;
    
    CGFloat past = fullFrame.origin.x;
    CGFloat food = fullFrame.origin.x + fullFrame.size.width;
    CGFloat sink = fullFrame.origin.y;
    CGFloat half = fullFrame.origin.y + fullFrame.size.height;
    
    CGPoint originCenter = center;
    
    switch (edge) {
        case DailyLiveTextRowDidExceeds:
            originCenter.x = past + self.bounds.size.width/2 + _tagPushOffDrop;
            break;
        case LayoutStrokedSensorStaticTwitterAspect:
            originCenter.x = food - self.bounds.size.width/2 - _tagPushOffDrop;
            break;
        case MinSobSnapConfigureFold:
            originCenter.y = sink + self.bounds.size.height/2 + _tagPushOffDrop;
            break;
        case SayLargeInitiallyPrintedTheLong:
            originCenter.y = half - self.bounds.size.height/2 - _tagPushOffDrop;
            break;
        default:
            break;
    }
    
    
    return [self assumeTriggerBinCustodianSecondaryCupIndicatorCenter:originCenter];
}


- (CGPoint)rowCutoffSomaliHoverDanishReachedPhotosEdge:(ClockSettingEdge)edge {
    CGPoint alignCenter = CGPointMake(0, 0);
    
    switch (edge) {
        case DailyLiveTextRowDidExceeds:
            alignCenter.x = self.bounds.size.width;
            break;
        case LayoutStrokedSensorStaticTwitterAspect:
            
            break;
        case MinSobSnapConfigureFold:
            alignCenter.x = self.bounds.size.width;
            alignCenter.y = self.bounds.size.height;
            break;
        case SayLargeInitiallyPrintedTheLong:
            alignCenter.x = self.bounds.size.width;
            break;
        default:
            break;
    }
    
    return alignCenter;
}


- (void)directoryBurstFollowZeroWeekendTimer {
    if (_redDownhillRangingCommentOpt <= 0) return;
    
    [self fixExtrasColorSaturatedDrum];
    _fisheyeSphereTimer = [NSTimer scheduledTimerWithTimeInterval:_redDownhillRangingCommentOpt
                                                     target:self
                                                   selector:@selector(wayMayWorkingUpsideRecorder)
                                                   userInfo:nil
                                                    repeats:NO];
}

- (void)fixExtrasColorSaturatedDrum {
    [_fisheyeSphereTimer invalidate];
    _fisheyeSphereTimer = nil;
}

- (void)wayMayWorkingUpsideRecorder {
    [UIView animateWithDuration:0.3 animations:^{
        self.jobUplinkView.alpha = 0.5;
        
        CGRect frame = self.frame;
        switch (self.catCompositeEdge) {
            case DailyLiveTextRowDidExceeds:
                frame.origin.x -= self.tagPushOffDrop;
                break;
            case LayoutStrokedSensorStaticTwitterAspect:
                frame.origin.x += self.tagPushOffDrop;
                break;
            case MinSobSnapConfigureFold:
                frame.origin.y -= self.tagPushOffDrop;
                break;
            case SayLargeInitiallyPrintedTheLong:
                frame.origin.y += self.tagPushOffDrop;
                break;
            default:
                break;
        }
        self.frame = frame;
    }];
}


- (void)inverseAlertMirroredEvaluatedUndoAny {
    [self nothingMasterLeftStepsonCentering];
    [self friendWorkLoadGermanExtentWritten]; 
    [self surrogateRejectUtilitiesAggregateAlertBeginAnimation:YES];
}


- (void)nothingMasterLeftStepsonCentering {
    UIWindow *keyWindow = SoloSlantManager.shared.foggyTiedDueWindow; //self.stereoSyntaxWindow;
    UIEdgeInsets safeArea = UIEdgeInsetsZero;
    if (![UIDevice jouleSob]) {
        safeArea = UIEdgeInsetsZero;
    }else if([UIDevice minPub]) {
        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.performsNeedPunjabiEncryptedSob = safeArea;
    self.followerExclusionTriangleHerSpecificRound = keyWindow.bounds;
}

- (CGRect)patchRetLocalesStakeIntentFrame {
    
    return CGRectMake(
        self.followerExclusionTriangleHerSpecificRound.origin.x + self.performsNeedPunjabiEncryptedSob.left,
        self.followerExclusionTriangleHerSpecificRound.origin.y + self.performsNeedPunjabiEncryptedSob.top,
        self.followerExclusionTriangleHerSpecificRound.size.width - (self.performsNeedPunjabiEncryptedSob.left + self.performsNeedPunjabiEncryptedSob.right),
        self.followerExclusionTriangleHerSpecificRound.size.height - (self.performsNeedPunjabiEncryptedSob.top + self.performsNeedPunjabiEncryptedSob.bottom)
    );
}


- (void)slightMalformedPrologPhoneticExtentsLuminance {
    NSString *hindiSlashed = [[NSUserDefaults standardUserDefaults] valueForKey:HexDiscrete.shelfTenSide.ukrainianHeadSecondaryUpdateFactPolicies];
    if (hindiSlashed) {
        self.center = CGPointFromString(hindiSlashed);
    }else {
        
        CGRect fullFrame = [self patchRetLocalesStakeIntentFrame];
        self.center = CGPointMake(fullFrame.origin.x + fullFrame.size.width - self.bounds.size.width/2 - _tagPushOffDrop,
                                  fullFrame.origin.y + fullFrame.size.height/2);
    }
}


- (UIWindow *)mayComposerPositiveQuechuaPencilWindow {
    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)assumeTriggerBinCustodianSecondaryCupIndicatorCenter:(CGPoint)proposedCenter {
    CGRect fullFrame = [self patchRetLocalesStakeIntentFrame];
    CGSize buttonSize = self.bounds.size;
    
    CGFloat past = fullFrame.origin.x + buttonSize.width/2;
    CGFloat food = fullFrame.origin.x + fullFrame.size.width - buttonSize.width/2;
    CGFloat sink = fullFrame.origin.y + buttonSize.height/2;
    CGFloat half = fullFrame.origin.y + fullFrame.size.height - buttonSize.height/2;
    
    return CGPointMake(
        MAX(past, MIN(proposedCenter.x, food)),
        MAX(sink, MIN(proposedCenter.y, half))
    );
}

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

@end