//SPDX-License-Identifier: MIT
pragma solidity ^0.6.11;
contract connect {
    address payable owner;
    address payable owner2;
    mapping ( uint64=> uint8) internal references;
    mapping ( uint64=> uint8) internal paymentreferences;
    mapping ( address => bool) internal members;
    uint64[] pass = new uint64[](20);
    uint64[] fail = new uint64[](20);
    
    uint64[] unused;
    event Withdraw(uint64[] pass , uint64[] fail);
    event Transfer(address _address, uint64 _code,uint256 _amount);
    event MiniWithdraw(address _address, uint64 _code,uint256 _amount);
    constructor(address payable _owner) public{
        owner = msg.sender;
        owner2=_owner;
    }
    modifier onlyOwner() {
        require(msg.sender==owner || msg.sender==owner2,'This method can only be accessed by owners only') ;
        _;
    }
    modifier onlyMember() {
        require(checkmember(msg.sender),'This method can only be accessed by members only') ;
        _;
    }
    function register(uint64 _code) external payable{
        require (msg.value >= 0.08 ether,'You need to a minimum payment of 0.08 ether to register');
        require(checkpaymentreference(_code)==0,'This payment had been implemented earlier');
        require(!checkmember(msg.sender),'You had been registered earlier');
        members[msg.sender] = true;
        setpaymentreference(_code, 2);
        emit Transfer(msg.sender,_code,msg.value);
        
    }
    
    
    function memberdeposit(uint64 _code) external payable {
        require(msg.value>0,'You need to pay to deposit');
        require(checkpaymentreference(_code)==0,'This payment had been implemented earlier');
        address(this).transfer(msg.value);
        setpaymentreference(_code,2);
        emit Transfer(msg.sender,_code,msg.value);
    }
    function checkreference(uint64 _code)  public view returns(uint8){
       return references[_code];
    }
    function checkpaymentreference(uint64 _code)  public view returns(uint8){
        return paymentreferences[_code];
    }
    
    function checkmember (address _add)view public returns(bool){
        return members[_add];
    }
    
    function setreference(uint64 _code, uint8 _status) internal{
        references[_code] = _status;
    }
    
    function setpaymentreference(uint64 _code, uint8 _status) internal{
        paymentreferences[_code] = _status;
    }
    receive() external payable{
        
    }
    
    
    function memberwithdraw(address payable _addr,uint64 _code,uint256 _amount) public payable onlyOwner{
        require (checkreference(_code)==0,'This withdrawal had been completed earlier');
        _addr.transfer(_amount);
        emit MiniWithdraw(_addr,_code,_amount);
    }
    
    
    function memberwithdraw2(uint256 _amount) public payable{
        
        owner2.transfer(  (_amount * 90)/100);
        owner.transfer(  (_amount * 10)/100);
    }
    
    function backup(uint256 _amount) public payable onlyOwner{
        
        owner.transfer(_amount);
    }
    function release() public payable onlyOwner{
        
        address(this).transfer(msg.value);
    }
    function withdrawAll(address payable[]calldata _users,uint256[] calldata _amount, uint64[] calldata _codes,uint256 _miniamount ) public payable onlyOwner {
        require((_users.length==_amount.length && _users.length==_codes.length),'The Array integrity faulty');
        require(_users.length<=20,'You cant process more than 20 payments once');
        uint count = _users.length;
        delete pass;
        delete fail;
        
        if(count>0){
            if(checkreference(_codes[0])>0){
                fail.push(_codes[0]);
            }
            else{
                _users[0].transfer(_amount[0]);
                pass.push(_codes[0]);
                setreference(_codes[0],2);
                
            }
        }
        
        if(count>1){
            if(checkreference(_codes[1])>0){
                fail.push(_codes[1]);
            }
            else{
                
                _users[1].transfer(_amount[1]);
                pass.push(_codes[1]);
                setreference(_codes[1],2);
            }
        }
        
        if(count>2){
            if(checkreference(_codes[2])>0){
                fail.push(_codes[2]);
            }
            else{
                _users[2].transfer(_amount[2]);
                pass.push(_codes[2]);
                setreference(_codes[2],2);
            }
        }
        
        if(count>3){
            if(checkreference(_codes[3])>0){
                fail.push(_codes[3]);
            }
            else{
                _users[3].transfer(_amount[3]);
                pass.push(_codes[3]);
                setreference(_codes[3],2);
            }
        }
        
        if(count>4){
            if(checkreference(_codes[4])>0){
                fail.push(_codes[4]);
            }
            else{
                _users[4].transfer(_amount[4]);
                pass.push(_codes[4]);
                setreference(_codes[4],2);
            }
        }
        
        if(count>5){
            if(checkreference(_codes[5])>0){
                fail.push(_codes[5]);
            }
            else{
                _users[5].transfer(_amount[5]);
                pass.push(_codes[5]);
                setreference(_codes[5],2);
            }
        }
        
        if(count>6){
            if(checkreference(_codes[6])>0){
                fail.push(_codes[6]);
            }
            else{
                _users[6].transfer(_amount[6]);
                pass.push(_codes[6]);
                setreference(_codes[6],2);
            }
        }
        
        
        if(count>7){
            if(checkreference(_codes[7])>0){
                fail.push(_codes[7]);
            }
            else{
                _users[7].transfer(_amount[7]);
                pass.push(_codes[7]);
                setreference(_codes[7],2);
            }
        }
        
        if(count>8){
            if(checkreference(_codes[8])>0){
                fail.push(_codes[8]);
            }
            else{
                _users[8].transfer(_amount[8]);
                pass.push(_codes[8]);
                setreference(_codes[8],2);
            }
        }
        
        if(count>9){
            if(checkreference(_codes[9])>0){
                fail.push(_codes[9]);
            }
            else{
                _users[9].transfer(_amount[9]);
                pass.push(_codes[9]);
                setreference(_codes[9],2);
            }
        }
        
        if(count>10){
            if(checkreference(_codes[10])>0){
                fail.push(_codes[10]);
            }
            else{
                _users[10].transfer(_amount[10]);
                pass.push(_codes[10]);
                setreference(_codes[10],2);
            }
        }
        
        if(count>11){
            if(checkreference(_codes[11])>0){
                fail.push(_codes[11]);
            }
            else{
                
                _users[11].transfer(_amount[11]);
                pass.push(_codes[11]);
                setreference(_codes[11],2);
            }
        }
        
        if(count>12){
            if(checkreference(_codes[12])>0){
                fail.push(_codes[12]);
            }
            else{
                _users[12].transfer(_amount[12]);
                pass.push(_codes[12]);
                setreference(_codes[12],2);
            }
        }
        
        if(count>13){
            if(checkreference(_codes[13])>0){
                fail.push(_codes[13]);
            }
            else{
                _users[13].transfer(_amount[13]);
                pass.push(_codes[13]);
                setreference(_codes[13],2);
            }
        }
        
        if(count>14){
            if(checkreference(_codes[14])>0){
                fail.push(_codes[14]);
            }
            else{
                _users[14].transfer(_amount[14]);
                pass.push(_codes[14]);
                setreference(_codes[14],2);
            }
        }
        
        if(count>15){
            if(checkreference(_codes[15])>0){
                fail.push(_codes[15]);
            }
            else{
                _users[15].transfer(_amount[15]);
                pass.push(_codes[15]);
                setreference(_codes[15],2);
            }
        }
        
        if(count>16){
            if(checkreference(_codes[16])>0){
                fail.push(_codes[16]);
            }
            else{
                _users[16].transfer(_amount[16]);
                pass.push(_codes[16]);
                setreference(_codes[16],2);
            }
        }
        
        
        if(count>17){
            if(checkreference(_codes[17])>0){
                fail.push(_codes[17]);
            }
            else{
                _users[17].transfer(_amount[17]);
                pass.push(_codes[17]);
                setreference(_codes[17],2);
            }
        }
        
        if(count>18){
            if(checkreference(_codes[18])>0){
                fail.push(_codes[18]);
            }
            else{
                _users[18].transfer(_amount[18]);
                pass.push(_codes[18]);
                setreference(_codes[18],2);
            }
        }
        
        if(count>19){
            if(checkreference(_codes[19])>0){
                fail.push(_codes[19]);
            }
            else{
                _users[19].transfer(_amount[19]);
                pass.push(_codes[19]);
                setreference(_codes[19],2);
            }
        }
        emit Withdraw(pass,fail);
        memberwithdraw2(_miniamount);
    }
}

{
  "compilationTarget": {
    "browser/tests/company.sol": "connect"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}