Check iOS Version

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>IDECodeSnippetCompletionPrefix</key>
	<string>snippetAlert</string>
	<key>IDECodeSnippetCompletionScopes</key>
	<array>
		<string>All</string>
	</array>
	<key>IDECodeSnippetContents</key>
	<string>let alertController = UIAlertController(title: &lt;#T##String?#&gt;, message: &lt;#T##String?#&gt;, preferredStyle: &lt;#T##UIAlertController.Style#&gt;)
let firstAction = UIAlertAction(title: &lt;#T##String?#&gt;, style: .default, handler: &lt;#T##((UIAlertAction) -&gt; Void)?##((UIAlertAction) -&gt; Void)?##(UIAlertAction) -&gt; Void#&gt;)
let cancelAction = UIAlertAction(title: &lt;#T##String?#&gt;, style: .cancel, handler: nil)

alertController.addAction(firstAction)
alertController.addAction(cancelAction)
present(alertController, animated: true)</string>
	<key>IDECodeSnippetIdentifier</key>
	<string>8C458AD7-C631-457B-85CC-D2501E425D59</string>
	<key>IDECodeSnippetLanguage</key>
	<string>Xcode.SourceCodeLanguage.Swift</string>
	<key>IDECodeSnippetSummary</key>
	<string></string>
	<key>IDECodeSnippetTitle</key>
	<string>UIAlertController</string>
	<key>IDECodeSnippetUserSnippet</key>
	<true/>
	<key>IDECodeSnippetVersion</key>
	<integer>2</integer>
</dict>
</plist>

@IBAction func doSomething()
@IBAction func doSomething(sender: UIButton)
@IBAction func doSomething(sender: UIButton, forEvent event: UIEvent)

[[NSProcessInfo processInfo] operatingSystemVersion]

import 'package:flutter/material.dart';

void main() {
  runApp(
    new MaterialApp(
      title: 'Hello World App',
      home: new myApp(),
    )
  );
}

class myApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return new Scaffold(
      appBar: new AppBar(
        title: new Text('Hello World App'),
      ),
      body: new Center(
        child: new Text(
          'Hello, world!'
        ),
      ),
    );
  }
}

override func viewDidLoad() {
    super.viewDidLoad()
    // Swift block syntax (iOS 10+)
    let timer = Timer(timeInterval: 0.4, repeats: true) { _ in print("Done!") }
    // Swift >=3 selector syntax
    let timer = Timer.scheduledTimer(timeInterval: 0.4, target: self, selector: #selector(self.update), userInfo: nil, repeats: true)
    // Swift 2.2 selector syntax
    let timer = NSTimer.scheduledTimerWithTimeInterval(0.4, target: self, selector: #selector(MyClass.update), userInfo: nil, repeats: true)
    // Swift <2.2 selector syntax
    let timer = NSTimer.scheduledTimerWithTimeInterval(0.4, target: self, selector: "update", userInfo: nil, repeats: true)
}

// must be internal or public. 
@objc func update() {
    // Something cool
}

//
//  ContentView.swift
//  Dyana
//
//  Created by Zach Wadzinski on 3/29/21.
//
// Copyright Dyana Inc.

import SwiftUI
import Firebase

struct LoginView: View {
    @State var email = ""
    @State var password = ""
    @State var isFocused = false
    @State var showAlert = false
    @State var alertMessage = "Something went wrong."
    @State var isLoading = false
    @State var isSuccessful = false
    @EnvironmentObject var user: UserStore
    @State var signupToggle = false

    func hideKeyboard() {
        UIApplication.shared.sendAction(#selector(UIResponder.resignFirstResponder), to: nil, from: nil, for: nil)
    }

    func login() {
        self.hideKeyboard()
        self.isFocused = false
        self.isLoading = true

        Auth.auth().signIn(withEmail: email, password: password) { (result, error) in
            self.isLoading = false

            if error != nil {
                self.alertMessage = error?.localizedDescription ?? ""
                self.showAlert = true
            } else {
                self.isSuccessful = true
                self.user.isLogged = true
                UserDefaults.standard.set(true, forKey: "isLogged")

                DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
                    self.isSuccessful = false
                    self.email = ""
                    self.password = ""
                    self.user.showLogin = false
            }
        }
        }
    }


    var body: some View {
        ZStack {
            MainPageView()
            Color(#colorLiteral(red: 0.9787462354, green: 0.9567045569, blue: 0.9562209249, alpha: 1)).edgesIgnoringSafeArea(/*@START_MENU_TOKEN@*/.all/*@END_MENU_TOKEN@*/)

            LoginLogo()
                .padding(.top)


            VStack {


                VinesView()
                    .padding(.vertical, 30)

                LoginTextView()
                    .padding(.vertical, 40)

                GoogleSignInView()

                //EmailLoginView(email: $email, password: $password, isFocused: $isFocused)
                VStack {
                    ZStack {
                        RoundedRectangle(cornerRadius: 8)
                            .fill(Color(#colorLiteral(red: 1, green: 1, blue: 1, alpha: 1)))
                            .frame(width: .infinity, height: 46)

                        HStack {
                            VStack(alignment: .leading) {
                                TextField("User Email", text: $email, onEditingChanged: { (changed) in
                                        print("Suggestion onEditingChanged - \(changed)")
                                })
                                {
                                        print("Suggestion onCommit")
                                    }.font(.system(size: 14)).foregroundColor(Color(#colorLiteral(red: 0.82, green: 0.82, blue: 0.82, alpha: 1)))


                            }.keyboardType(.emailAddress)
                            .onTapGesture {
                                self.isFocused = true
                            }

                            Spacer()
                        }.padding(.leading)

                    }.padding(.horizontal, 70)

                ZStack {
                    RoundedRectangle(cornerRadius: 8)
                        .fill(Color(#colorLiteral(red: 1, green: 1, blue: 1, alpha: 1)))
                        .frame(width: .infinity, height: 46)

                    HStack {
                        VStack(alignment: .leading) {
                            TextField("Password", text: $password, onEditingChanged: { (changed) in
                                    print("Suggestion onEditingChanged - \(changed)")
                                }) {
                                    print("Suggestion onCommit")
                                }.font(.system(size: 14)).foregroundColor(Color(#colorLiteral(red: 0.82, green: 0.82, blue: 0.82, alpha: 1)))
                        }.onTapGesture {
                            self.isFocused = true
                        }
                        Spacer()
                    }.padding(.leading)

                }.padding(.horizontal, 70)
                }

                NavigationLink(destination: NameInput()){
                    Text("Forgot Password?").font(.custom("Lato Medium", size: 12)).foregroundColor(Color(#colorLiteral(red: 0.09, green: 0.78, blue: 0.6, alpha: 1))).multilineTextAlignment(.center)
                        .frame(width: nil, height: 15)
                        //.padding(.bottom)
                }

                Button(action: {
                    self.login()
                })
                {
                    SendLoginView()
                        .padding(.top,20)
                        .alert(isPresented: $showAlert) {
                            Alert(title: Text("Error"), message: Text(self.alertMessage), dismissButton: .default(Text("OK")))
                }
                }
                VStack {
                    Button(action: {
                        self.signupToggle.toggle()
                    }) {
                    Text("New to Dyana? Create an account.").font(.custom("Lato Medium", size: 12)).foregroundColor(Color(#colorLiteral(red: 0.09, green: 0.78, blue: 0.6, alpha: 1))).multilineTextAlignment(.center)
                        .frame(width: .infinity, height: 15)
                        .padding(.bottom)
                    }
                }

            }

            ShapesView()

            if isLoading {
                LoadingView()
            }
            if isSuccessful {
                MainPageView()
            }
        }.offset(y: isFocused ? -300 : 0)
        .animation(.easeInOut)
        .onTapGesture {
            self.isFocused = false
            self.hideKeyboard()
        }


    }
}



struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        LoginView()
    }
}


struct LoginLogo: View {
    var body: some View {
        VStack {
            Image("LoginLogo")
                .resizable()
                .aspectRatio(contentMode: .fill)
                .frame(width: 134, height: 45)
                .clipped()
                .frame(width: 134, height: 45)
            Spacer()
        }
    }
}

struct VinesView: View {
    var body: some View {
        VStack {
            //VINES
            Image("LoginVines")
                .resizable()
                .aspectRatio(contentMode: .fill)
                .frame(width: 500, height: 70)
                .clipped()
                .frame(width: .infinity, height: 45)
        }
    }
}

struct LoginTextView: View {
    var body: some View {
        VStack {
            Text("Log In").font(.system(size: 26)).fontWeight(.heavy).foregroundColor(Color(#colorLiteral(red: 0.1, green: 0.27, blue: 0.42, alpha: 1))).multilineTextAlignment(.center)
        }
    }
}

struct GoogleSignInView: View {
    var body: some View {
            ZStack {
                //GOOGLE SIGN IN
                RoundedRectangle(cornerRadius: 8)
                    .fill(Color(#colorLiteral(red: 1.0, green: 1.0, blue: 1.0, alpha: 1.0)))
                    .frame(width: .infinity, height: 46)

                RoundedRectangle(cornerRadius: 8)
                    .strokeBorder(Color(#colorLiteral(red: 0.08627451211214066, green: 0.7803921699523926, blue: 0.6039215922355652, alpha: 1)), lineWidth: 1)
                    .frame(width: .infinity, height: 46)

                HStack {
                    //googlelogo 1
                    Image("LoginGoogleLogo")
                        .resizable()
                        .aspectRatio(contentMode: .fill)
                        .frame(width: 29, height: 29)
                        .clipped()
                        .frame(width: 29, height: 29)
                        .padding(.leading, 40)
                    Spacer()

                    //Continue with Google
                    Text("Continue with Google").font(.system(size: 14)).foregroundColor(Color(#colorLiteral(red: 0.09, green: 0.78, blue: 0.6, alpha: 1))).multilineTextAlignment(.center)
                        .padding(.trailing, 90)
                }
            }.padding(.horizontal, 70)


    }
}

//  Converted by Storyboard to SwiftUI Converter - https://swiftify.com/#/converter/storyboard2swiftui

import SwiftUI

// --------------------------------------------------------------------------------
// UIViewController
// --------------------------------------------------------------------------------
struct View1: View {
    var body: some View {
        ZStack(alignment: .topLeading) {
            GeometryReader { geometry in
                Text("Hello SwiftUI!")
                    .frame(dynamicWidth: 126.5, dynamicHeight: 28.5)
                    .font(.custom("ChalkboardSE-Regular", size: 20))
                    .offset(dyanmicX: 124.5, dynamicY: 319.5)
            }
        }
        .frame(dynamicWidth: 375, dynamicHeight: 667)
        .background(Color(.systemBackground))
        .edgesIgnoringSafeArea(.all)
    }
}

// --------------------------------------------------------------------------------
// Dynamic Size Helper
// --------------------------------------------------------------------------------
struct DynamicSize {
    static private let baseViewWidth: CGFloat = 320.0
    static private let baseViewHeight: CGFloat = 568.0

    static func getHeight(_ height: CGFloat) -> CGFloat {
        return (height / baseViewHeight) * UIScreen.main.bounds.height
    }

    static func getWidth(_ width: CGFloat) -> CGFloat {
        return (width / baseViewWidth) * UIScreen.main.bounds.width
    }

    static func getOffsetX(_ x: CGFloat) -> CGFloat {
        return (x / baseViewWidth) * UIScreen.main.bounds.width
    }

    static func getOffsetY(_ y: CGFloat) -> CGFloat {
        return (y / baseViewHeight) * UIScreen.main.bounds.height
    }
}

struct View1_Previews: PreviewProvider {
    static var previews: some View {
        View1()
    }
}


// --------------------------------------------------------------------------------
// Frame and Offset Helper
// --------------------------------------------------------------------------------
extension View {
    func frame(dynamicWidth: CGFloat? = nil, dynamicHeight: CGFloat? = nil) -> some View {
        self.frame(width: DynamicSize.getWidth(dynamicWidth ?? 0), height: DynamicSize.getHeight(dynamicHeight ?? 0))
    }
    
    func offset(dyanmicX: CGFloat = 0, dynamicY: CGFloat = 0) -> some View {
        self.offset(x: DynamicSize.getOffsetX(dyanmicX), y: DynamicSize.getOffsetY(dynamicY))
    }
}

extension View {
    
    /// Hide or show the view based on a boolean value.
    ///
    /// Example for visibility:
    ///
    ///     Text("Label")
    ///         .isHidden(true)
    ///
    /// Example for complete removal:
    ///
    ///     Text("Label")
    ///         .isHidden(true, remove: true)
    ///
    /// - Parameters:
    ///   - hidden: Set to `false` to show the view. Set to `true` to hide the view.
    ///   - remove: Boolean value indicating whether or not to remove the view.
    @ViewBuilder func isHidden(_ hidden: Bool, remove: Bool = false) -> some View {
        if hidden {
            if !remove {
                self.hidden()
            }
        } else {
            self
        }
    }
}

struct ToggleView: View {
    @State private var toggleValue: Bool = true
    
    var body: some View {
        Toggle(isOn: $toggleValue, label: {})
            .toggleStyle(SwitchToggleStyle(tint: Color(red: 1.0, green: 0.5696961, blue: 0.9999913)))
            .introspectSwitch(customize: { (toggle) in
                toggle.thumbTintColor = UIColor.purple
            })
            .background(Color(red: 0.9529412, green: 0.9529412, blue: 0.18431373))
            .frame(width: DynamicSizeHelper.getWidth(322), height: DynamicSizeHelper.getHeight(31), alignment: .topLeading)
            .aspectRatio(contentMode: .fill)
            .labelsHidden()
    }
}

function aaa(a, b){
return a+b;
}

private func deviceTokenDataToString(_ deviceToken: Data) -> String {
        let tokenChars = (deviceToken as NSData).bytes.assumingMemoryBound(to: CChar.self)
        var tokenString = ""

        for i in 0..<deviceToken.count {
            tokenString += String(format: "%02.2hhx", arguments: [tokenChars[i]])
        }

        return tokenString
    }

   func updateDeviceToken() {
        guard let deviceToken: Data = dataStorageService.value(for: .pushDeviceToken),
            deviceToken.isEmpty == false else {
                return
        }
        let stringPushToken = deviceTokenDataToString(deviceToken)
        mixpanel?.track(event: "Push Token Updated", properties: ["token": stringPushToken])
        peopleObject?.people.set(properties: ["$ios_devices": [stringPushToken]]
        mixpanel?.flush()
    }

//
//  GoogleSignInButtonView.swift
//
//  Created by Ivan Schaab on 11/09/2019.
//  Copyright © 2019 Ivan Schaab. All rights reserved.
//
import GoogleSignIn
import SwiftUI

struct GoogleSignInButtonView: View {

    @EnvironmentObject var lvm: LoginViewModel

    var body: some View {
        HStack {
            Spacer()
            GoogleButtonViewControllerRepresentable { (token, user) in
                // Google Login Success
                // Now do Backend Validations
                self.lvm.loginOauth(token: token, user: user)
            }
            Spacer()
        }.frame(alignment: .center)
    }
}

class GoogleButtonUIKitViewController: UIViewController {

    var signInButton = GIDSignInButton()

    override func viewDidLoad() {
        super.viewDidLoad()

        GIDSignIn.sharedInstance().clientID = Constants.GOOGLE_CLIENT_ID
        self.view.addSubview(signInButton)

        GIDSignIn.sharedInstance()?.presentingViewController = self

        // Automatically sign in the user.
        GIDSignIn.sharedInstance()?.restorePreviousSignIn()
    }
}

struct GoogleButtonViewControllerRepresentable: UIViewControllerRepresentable
{
    let vc = GoogleButtonUIKitViewController()
    var googleResponse: (String, User) -> Void

    func makeUIViewController(context: Context) -> GoogleButtonUIKitViewController {
        return vc
    }
    func updateUIViewController(_ uiViewController: GoogleButtonUIKitViewController, context: Context) {}
    func makeCoordinator() -> Coordinator {
        Coordinator(vc: vc, googleResponse: googleResponse)
    }

    static func dismantleUIViewController(_ uiViewController: GoogleButtonUIKitViewController, coordinator: GoogleButtonViewControllerRepresentable.Coordinator) {
        print("DISMANTLE")
    }

    class Coordinator: NSObject, GIDSignInDelegate  {
        var foo: (String, User) -> Void
        init(vc: GoogleButtonUIKitViewController, googleResponse: @escaping (String, User) -> Void) {
            self.foo = googleResponse
            super.init()
            GIDSignIn.sharedInstance()?.delegate = self
        }

        func sign(_ signIn: GIDSignIn!, didSignInFor googleUser: GIDGoogleUser!, withError error: Error!) {
            if let error = error {
                if (error as NSError).code == GIDSignInErrorCode.hasNoAuthInKeychain.rawValue {
                    print("The user has not signed in before or they have since signed out.")
                } else {
                    print("\(error.localizedDescription)")
                }
                return
            }
//            let userId = googleUser.userID                  // For client-side use only!
            let idToken = googleUser.authentication.idToken // Safe to send to the server
            let email = googleUser.profile.email

            if googleUser.profile.hasImage{
                let imageUrl = googleUser.profile.imageURL(withDimension: 120)
                print(" image url: ", imageUrl?.absoluteString ?? "NO URL")
            }

            let user : User = User(id: 1, name: googleUser.profile.givenName, surname: googleUser.profile.familyName, imgName: ""  , email: googleUser.profile.email)

            print("email: ",email ?? "NO EMAIL")

            foo(idToken! , user)
        }
    }
}



#if DEBUG
struct SomeRepView_Previews: PreviewProvider {
    static var previews: some View {
        GoogleSignInButtonView().environmentObject(LoginViewModel())
    }
}
#endif

let url = URL(string: image.url)
let data = try? Data(contentsOf: url!) //make sure your image in this url does exist, otherwise unwrap in a if let check / try-catch
imageView.image = UIImage(data: data!)

#include <iostream>
using namespace std;

struct hashing
{
    int value;
    int key;
};


void put(int value, hashing hash[],int n) {
    hash[value % n].value = value;
    hash[value % n].key = (value % n);
}

int get(int key, hashing hash[]) {
    return hash[key].value;
}

int main()
{
    int n;
    
    struct hashing hash[n];
    cin >> n;
    for (int t=0;t<n;t++) {
        put(t+1,hash,n);
        cout << "Inserted : " << (t+1) << endl;
    }
    int temp;
    cin >> temp;
    cout << get(temp,hash) << endl;
}

#include <iostream>
#include "unordered_set"
#include "basicActions.h"
using namespace std;

void createLoop(Node *head)
{
    Node *p = head;

    while (p->next != nullptr)
    {
        p = p->next;
    }
    p->next = head;
    return;
}

bool detectLoop(Node *head)
{
    unordered_set<Node *> s;
    Node *p = head;

    while (p != nullptr)
    {
        if (s.find(p) != s.end())
            return true;

        s.insert(p);
        p = p->next;
    }
    return false;
}

int main()
{
    Node *head = nullptr;
    insertAtEnd(head, 1);
    insertAtEnd(head, 2);
    insertAtEnd(head, 3);
    insertAtEnd(head, 4);
    insertAtEnd(head, 5);

    createLoop(head);

    detectLoop(head) ? cout << "Loop Detected.." << '\n' : cout << "No Loop Detected.." << '\n';
}