#
#  Panoramix v4 Oct 2019 
#  Decompiled source of bsc:0xaAcb683A934a5E1aEE846286049F1a5Dd38bDfb9
# 
#  Let's make the world open source 
# 
#
#  I failed with these: 
#  - _fallback()
#  All the rest is below.
#

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 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 implementation=_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 previousAdmin=storB531,
        address newAdmin=_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 implementation=_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

Python Online Compiler

Write, Run & Share Python code online using OneCompiler's Python online compiler for free. It's one of the robust, feature-rich online compilers for python language. Getting started with the OneCompiler's Python editor is easy and fast. The editor shows sample boilerplate code when you choose language as Python or Python2. OneCompiler also has reference programs, where you can look for the sample code and start coding.

Taking inputs (stdin)

OneCompiler's python online editor supports stdin and users can give inputs to programs using the STDIN textbox under the I/O tab. Following is a sample python program which takes name as input and print your name with hello.

import sys
name = sys.stdin.readline()
print("Hello "+ name)

About Python

Python is a very popular general-purpose programming language which was created by Guido van Rossum, and released in 1991. It is very popular for web development and you can build almost anything like mobile apps, web apps, tools, data analytics, machine learning etc. It is designed to be simple and easy like english language. It's is highly productive and efficient making it a very popular language.

Tutorial & Syntax help

Loops

1. If-Else:

When ever you want to perform a set of operations based on a condition IF-ELSE is used.

if conditional-expression
    #code
elif conditional-expression
    #code
else:
    #code

Note:

Indentation is very important in Python, make sure the indentation is followed correctly

2. For:

For loop is used to iterate over arrays(list, tuple, set, dictionary) or strings.

Example:

mylist=("Iphone","Pixel","Samsung")
for i in mylist:
    print(i)

3. While:

While is also used to iterate a set of statements based on a condition. Usually while is preferred when number of iterations are not known in advance.

while condition  
    #code

Collections

There are four types of collections in Python.

1. List:

List is a collection which is ordered and can be changed. Lists are specified in square brackets.

Example:

mylist=["iPhone","Pixel","Samsung"]
print(mylist)

2. Tuple:

Tuple is a collection which is ordered and can not be changed. Tuples are specified in round brackets.

Example:

myTuple=("iPhone","Pixel","Samsung")
print(myTuple)

Below throws an error if you assign another value to tuple again.

myTuple=("iPhone","Pixel","Samsung")
print(myTuple)
myTuple[1]="onePlus"
print(myTuple)

3. Set:

Set is a collection which is unordered and unindexed. Sets are specified in curly brackets.

Example:

myset{"iPhone","Pixel","Samsung"}
print{myset}

4. Dictionary:

Dictionary is a collection of key value pairs which is unordered, can be changed, and indexed. They are written in curly brackets with key - value pairs.

Example:

mydict = {
    "brand" :"iPhone",
    "model": "iPhone 11"
}
print(mydict)