 # Palkeoramix decompiler. 

def storage:
  stor3608 is addr at storage 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc
  storB531 is addr at storage 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103

def admin(): # not payable
  if caller == storB531:
      return storB531
  delegate stor3608 with:
     funct call.data[0 len 4]
       gas gas_remaining wei
      args call.data[4 len calldata.size - 4]
  if not delegate.return_code:
      revert with ext_call.return_data[0 len return_data.size]
  return ext_call.return_data[0 len return_data.size]

def implementation(): # not payable
  if caller == storB531:
      return stor3608
  delegate stor3608 with:
     funct call.data[0 len 4]
       gas gas_remaining wei
      args call.data[4 len calldata.size - 4]
  if not delegate.return_code:
      revert with ext_call.return_data[0 len return_data.size]
  return ext_call.return_data[0 len return_data.size]

def _fallback() payable: # default function
  if caller == storB531:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 
                  'TransparentUpgradeableProxy: admin cannot fallback to proxy target'
  delegate stor3608 with:
     funct call.data[0 len 4]
       gas gas_remaining wei
      args call.data[4 len calldata.size - 4]
  if not delegate.return_code:
      revert with ext_call.return_data[0 len return_data.size]
  return ext_call.return_data[0 len return_data.size]

def upgradeTo(address _implementation): # not payable
  require calldata.size - 4 >=ΓÇ▓ 32
  require _implementation == _implementation
  if storB531 != caller:
      delegate stor3608 with:
         funct call.data[0 len 4]
           gas gas_remaining wei
          args call.data[4 len calldata.size - 4]
      if not delegate.return_code:
          revert with ext_call.return_data[0 len return_data.size]
      return ext_call.return_data[0 len return_data.size]
  if not ext_code.size(_implementation):
      revert with 0, 'ERC1967: new implementation is not a contract'
  stor3608 = _implementation
  log Upgraded(address nextVersion=_implementation)

def changeAdmin(address _admin): # not payable
  require calldata.size - 4 >=ΓÇ▓ 32
  require _admin_ == _admin_
  if storB531 != caller:
      delegate stor3608 with:
         funct call.data[0 len 4]
           gas gas_remaining wei
          args call.data[4 len calldata.size - 4]
      if not delegate.return_code:
          revert with ext_call.return_data[0 len return_data.size]
      return ext_call.return_data[0 len return_data.size]
  log AdminChanged(
        address from=storB531,
        address to=_admin_)
  if not _admin_:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC1967: new admin is the zero address'
  storB531 = _admin_

def upgradeToAndCall(address _implementation, bytes _data) payable: 
  require calldata.size - 4 >=ΓÇ▓ 64
  require _implementation == _implementation
  require _data <= 18446744073709551615
  require _data + 35 <ΓÇ▓ calldata.size
  require _data.length <= 18446744073709551615
  require _data + _data.length + 36 <= calldata.size
  if storB531 != caller:
      delegate stor3608 with:
         funct call.data[0 len 4]
           gas gas_remaining wei
          args call.data[4 len calldata.size - 4]
      if not delegate.return_code:
          revert with ext_call.return_data[0 len return_data.size]
      return ext_call.return_data[0 len return_data.size]
  mem[128 len _data.length] = _data[all]
  mem[_data.length + 128] = 0
  if not ext_code.size(_implementation):
      revert with 0, 'ERC1967: new implementation is not a contract'
  stor3608 = _implementation
  log Upgraded(address nextVersion=_implementation)
  mem[ceil32(_data.length) + 128] = 39
  mem[ceil32(_data.length) + 160 len 39] = 0xfe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c65
  if not ext_code.size(_implementation):
      revert with 0, 'Address: delegate call to non-contract'
  mem[ceil32(_data.length) + 224 len ceil32(_data.length)] = _data[all], mem[_data.length + 128 len ceil32(_data.length) - _data.length]
  if ceil32(_data.length) > _data.length:
      mem[_data.length + ceil32(_data.length) + 224] = 0
  delegate _implementation.mem[ceil32(_data.length) + 224 len 4] with:
       gas gas_remaining wei
      args mem[ceil32(_data.length) + 228 len _data.length - 4]
  if not return_data.size:
      if delegate.return_code:
          stop
      if _data.length:
          revert with _data[all]
      mem[ceil32(_data.length) + 224] = 0x8c379a000000000000000000000000000000000000000000000000000000000
      mem[ceil32(_data.length) + 228] = 32
      mem[ceil32(_data.length) + 260] = Mask(8 * -ceil32(_data.length) + _data.length + 32, 0, 0), mem[_data.length + 160 len -_data.length + ceil32(_data.length)]
      mem[ceil32(_data.length) + 292 len ceil32(Mask(8 * -ceil32(_data.length) + _data.length + 32, 0, 0), mem[_data.length + 160 len -_data.length + ceil32(_data.length)])] = mem[ceil32(_data.length) + 160 len ceil32(Mask(8 * -ceil32(_data.length) + _data.length + 32, 0, 0), mem[_data.length + 160 len -_data.length + ceil32(_data.length)])]
      if ceil32(Mask(8 * -ceil32(_data.length) + _data.length + 32, 0, 0), mem[_data.length + 160 len -_data.length + ceil32(_data.length)]) > Mask(8 * -ceil32(_data.length) + _data.length + 32, 0, 0), mem[_data.length + 160 len -_data.length + ceil32(_data.length)]:
          mem[Mask(8 * -ceil32(_data.length) + _data.length + 32, 0, 0), mem[_data.length + 160 len -_data.length + ceil32(_data.length)] + ceil32(_data.length) + 292] = 0
      revert with memory
        from ceil32(_data.length) + 224
         len ceil32(Mask(8 * -ceil32(_data.length) + _data.length + 32, 0, 0), mem[_data.length + 160 len -_data.length + ceil32(_data.length)]) + 68
  mem[ceil32(_data.length) + 224] = return_data.size
  mem[ceil32(_data.length) + 256 len return_data.size] = ext_call.return_data[0 len return_data.size]
  if delegate.return_code:
      stop
  if return_data.size:
      revert with ext_call.return_data[0 len return_data.size]
  mem[ceil32(_data.length) + ceil32(return_data.size) + 225] = 0x8c379a000000000000000000000000000000000000000000000000000000000
  mem[ceil32(_data.length) + ceil32(return_data.size) + 229] = 32
  mem[ceil32(_data.length) + ceil32(return_data.size) + 261] = Mask(8 * -ceil32(_data.length) + _data.length + 32, 0, 0), mem[_data.length + 160 len -_data.length + ceil32(_data.length)]
  mem[ceil32(_data.length) + ceil32(return_data.size) + 293 len ceil32(Mask(8 * -ceil32(_data.length) + _data.length + 32, 0, 0), mem[_data.length + 160 len -_data.length + ceil32(_data.length)])] = mem[ceil32(_data.length) + 160 len ceil32(Mask(8 * -ceil32(_data.length) + _data.length + 32, 0, 0), mem[_data.length + 160 len -_data.length + ceil32(_data.length)])]
  if ceil32(Mask(8 * -ceil32(_data.length) + _data.length + 32, 0, 0), mem[_data.length + 160 len -_data.length + ceil32(_data.length)]) > Mask(8 * -ceil32(_data.length) + _data.length + 32, 0, 0), mem[_data.length + 160 len -_data.length + ceil32(_data.length)]:
      mem[Mask(8 * -ceil32(_data.length) + _data.length + 32, 0, 0), mem[_data.length + 160 len -_data.length + ceil32(_data.length)] + ceil32(_data.length) + ceil32(return_data.size) + 293] = 0
  revert with memory
    from ceil32(_data.length) + ceil32(return_data.size) + 225
     len ceil32(Mask(8 * -ceil32(_data.length) + _data.length + 32, 0, 0), mem[_data.length + 160 len -_data.length + ceil32(_data.length)]) + 68

created 2 years ago

Swift online compiler

Write, Run & Share Swift code online using OneCompiler’s Swift online compiler for free. It’s a fast and user-friendly platform to explore Swift programming right from your browser. Ideal for students, beginners, and professionals looking to prototype or test Swift code.

About Swift

Swift is a powerful and intuitive programming language developed by Apple for iOS, macOS, watchOS, and tvOS app development. It's designed to be safe, fast, and expressive, with modern features like optionals, closures, and type inference.

Sample Code

The following is a simple Swift program that prints a greeting:

import Foundation

print("Hello, OneCompiler!")

Taking inputs (stdin)

OneCompiler’s Swift editor supports standard input via the I/O tab. Here’s a sample Swift program that takes a user’s name and prints a greeting:

import Foundation

if let name = readLine() {
    print("Hello, \(name)!")
}

Syntax Basics

Variables

var age = 25          // Mutable variable
let name = "Swift"     // Constant

Data Types

Type	Description
Int	Whole numbers
Double	Decimal numbers
String	Sequence of characters
Bool	true or false
Array	Ordered collection
Dictionary	Key-value pairs

Conditionals

let score = 75
if score >= 50 {
    print("Pass")
} else {
    print("Fail")
}

Loops

For-in loop

for i in 1...5 {
    print(i)
}

While loop

var i = 1
while i <= 5 {
    print(i)
    i += 1
}

Repeat-While loop

var j = 1
repeat {
    print(j)
    j += 1
} while j <= 5

Functions

func greet(name: String) {
    print("Hello, \(name)!")
}

greet(name: "OneCompiler")

func add(a: Int, b: Int) -> Int {
    return a + b
}

This guide provides a quick reference to Swift programming syntax and features. Start writing Swift code using OneCompiler’s Swift online compiler today!