/*
** $Id: //Department/DaVinci/TRUNK/WiFi_P2P_Driver/os/linux/include/gl_p2p_ioctl.h#9 $
*/

/*! \file   gl_p2p_ioctl.h
    \brief  This file is for custom ioctls for Wi-Fi Direct only
*/

/*
** $Log: gl_p2p_ioctl.h $
**
** 07 26 2012 yuche.tsai
** [ALPS00324337] [ALPS.JB][Hot-Spot] Driver update for Hot-Spot
** Update driver code of ALPS.JB for hot-spot.
**
** 07 19 2012 yuche.tsai
** NULL
** Code update for JB.
 *
 * 07 17 2012 yuche.tsai
 * NULL
 * Compile no error before trial run.
 *
 * 06 07 2011 yuche.tsai
 * [WCXRP00000763] [Volunteer Patch][MT6620][Driver] RX Service Discovery Frame under AP mode Issue
 * Fix RX SD request under AP mode issue.
 *
 * 03 25 2011 wh.su
 * NULL
 * Fix P2P IOCTL of multicast address bug, add low power driver stop control.
 *
 * 11 22 2011 yuche.tsai
 * NULL
 * Update RSSI link quality of P2P Network query method. (Bug fix)
 *
 * 11 19 2011 yuche.tsai
 * NULL
 * Add RSSI support for P2P network.
 *
 * 11 11 2011 yuche.tsai
 * NULL
 * Fix work thread cancel issue.
 *
 * 11 08 2011 yuche.tsai
 * [WCXRP00001094] [Volunteer Patch][Driver] Driver version & supplicant version query & set support for service discovery version check.
 * Add support for driver version query & p2p supplicant verseion set.
 * For new service discovery mechanism sync.
 *
 * 10 25 2011 cm.chang
 * [WCXRP00001058] [All Wi-Fi][Driver] Fix sta_rec's phyTypeSet and OBSS scan in AP mode
 * .
 *
 * 10 18 2011 yuche.tsai
 * [WCXRP00001045] [WiFi Direct][Driver] Check 2.1 branch.
 * New 2.1 branch

 *
 * 08 16 2011 chinglan.wang
 * NULL
 * Add the group id information in the invitation indication.
 *
 * 08 09 2011 yuche.tsai
 * [WCXRP00000919] [Volunteer Patch][WiFi Direct][Driver] Invitation New Feature.
 * Invitation Feature add on.
 *
 * 05 04 2011 chinglan.wang
 * [WCXRP00000698] [MT6620 Wi-Fi][P2P][Driver] Add p2p invitation command for the p2p driver
 * .
 *
 * 03 29 2011 wh.su
 * [WCXRP00000095] [MT6620 Wi-Fi] [FW] Refine the P2P GO send broadcast protected code
 * add the set power and get power function sample.
 *
 * 03 22 2011 george.huang
 * [WCXRP00000504] [MT6620 Wi-Fi][FW] Support Sigma CAPI for power saving related command
 * link with supplicant commands
 *
 * 03 07 2011 wh.su
 * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
 * rename the define to anti_pviracy.
 *
 * 03 02 2011 wh.su
 * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
 * Add Security check related code.
 *
 * 03 01 2011 wh.su
 * [WCXRP00000488] [MT6620 Wi-Fi][Driver] Support the SIGMA set p2p parameter to driver
 * fixed the ioctl sumcmd to meet the p2p_supplicant setting.
 *
 * 02 23 2011 wh.su
 * [WCXRP00000488] [MT6620 Wi-Fi][Driver] Support the SIGMA set p2p parameter to driver
 * adding the ioctl set int define for p2p parameter.
 *
 * 02 22 2011 wh.su
 * [WCXRP00000488] [MT6620 Wi-Fi][Driver] Support the SIGMA set p2p parameter to driver
 * adding the ioctl set int from supplicant, and can used to set the p2p paramters
 *
 * 02 17 2011 wh.su
 * [WCXRP00000448] [MT6620 Wi-Fi][Driver] Fixed WSC IE not send out at probe request
 * adjust the set wsc ie structure.
 *
 * 01 05 2011 cp.wu
 * [WCXRP00000283] [MT6620 Wi-Fi][Driver][Wi-Fi Direct] Implementation of interface for supporting Wi-Fi Direct Service Discovery
 * ioctl implementations for P2P Service Discovery
 *
 * 12 22 2010 cp.wu
 * [WCXRP00000283] [MT6620 Wi-Fi][Driver][Wi-Fi Direct] Implementation of interface for supporting Wi-Fi Direct Service Discovery
 * 1. header file restructure for more clear module isolation
 * 2. add function interface definition for implementing Service Discovery callbacks
 *
 * 12 15 2010 cp.wu
 * NULL
 * invoke nicEnableInterrupt() before leaving from wlanAdapterStart()
 *
 * 12 07 2010 cp.wu
 * [WCXRP00000237] [MT6620 Wi-Fi][Wi-Fi Direct][Driver] Add interface for supporting service discovery
 * define a pair of i/o control for multiplexing layer
 *
 * 11 04 2010 wh.su
 * [WCXRP00000164] [MT6620 Wi-Fi][Driver] Support the p2p random SSID
 * adding the p2p random ssid support.
 *
 * 10 20 2010 wh.su
 * [WCXRP00000124] [MT6620 Wi-Fi] [Driver] Support the dissolve P2P Group
 * Add the code to support disconnect p2p group
 *
 * 09 21 2010 kevin.huang
 * [WCXRP00000054] [MT6620 Wi-Fi][Driver] Restructure driver for second Interface
 * Isolate P2P related function for Hardware Software Bundle
 *
 * 09 10 2010 george.huang
 * NULL
 * update iwpriv LP related
 *
 * 09 07 2010 wh.su
 * NULL
 * adding the code for beacon/probe req/ probe rsp wsc ie at p2p.
 *
 * 08 25 2010 cp.wu
 * NULL
 * add netdev_ops(NDO) for linux kernel 2.6.31 or greater
 *
 * 08 20 2010 yuche.tsai
 * NULL
 * Refine a function parameter name.
 *
 * 08 19 2010 cp.wu
 * NULL
 * add set mac address interface for further possibilities of wpa_supplicant overriding interface address.
 *
 * 08 16 2010 george.huang
 * NULL
 * add wext handlers to link P2P set PS profile/ network address function (TBD)
 *
 * 08 16 2010 cp.wu
 * NULL
 * revised implementation of Wi-Fi Direct io controls.
 *
 * 08 12 2010 cp.wu
 * NULL
 * follow-up with ioctl interface update for Wi-Fi Direct application
 *
 * 08 06 2010 cp.wu
 * NULL
 * driver hook modifications corresponding to ioctl interface change.
 *
 * 08 03 2010 cp.wu
 * NULL
 * [Wi-Fi Direct] add framework for driver hooks
 *
 * 07 08 2010 cp.wu
 *
 * [WPD00003833] [MT6620 and MT5931] Driver migration - move to new repository.
 *
 * 06 06 2010 kevin.huang
 * [WPD00003832][MT6620 5931] Create driver base
 * [MT6620 5931] Create driver base
 *
 * 06 01 2010 cp.wu
 * [WPD00003831][MT6620 Wi-Fi] Add framework for Wi-Fi Direct support
 * add ioctl to configure scan mode for p2p connection
 *
 * 05 31 2010 cp.wu
 * [WPD00003831][MT6620 Wi-Fi] Add framework for Wi-Fi Direct support
 * add cfg80211 interface, which is to replace WE, for further extension
 *
 * 05 17 2010 cp.wu
 * [WPD00003831][MT6620 Wi-Fi] Add framework for Wi-Fi Direct support
 * implement get scan result.
 *
 * 05 14 2010 cp.wu
 * [WPD00003831][MT6620 Wi-Fi] Add framework for Wi-Fi Direct support
 * implement wireless extension ioctls in iw_handler form.
 *
 * 05 14 2010 cp.wu
 * [WPD00003831][MT6620 Wi-Fi] Add framework for Wi-Fi Direct support
 * add ioctl framework for Wi-Fi Direct by reusing wireless extension ioctls as well
 *
 * 05 11 2010 cp.wu
 * [WPD00003831][MT6620 Wi-Fi] Add framework for Wi-Fi Direct support
 * p2p ioctls revised.
 *
 * 05 11 2010 cp.wu
 * [WPD00003831][MT6620 Wi-Fi] Add framework for Wi-Fi Direct support
 * add ioctl for controlling p2p scan phase parameters
 *
*/

#ifndef _GL_P2P_IOCTL_H
#define _GL_P2P_IOCTL_H

/*******************************************************************************
*                         C O M P I L E R   F L A G S
********************************************************************************
*/

/*******************************************************************************
*                    E X T E R N A L   R E F E R E N C E S
********************************************************************************
*/
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/wireless.h>
#if CFG_ENABLE_WIFI_DIRECT_CFG_80211
    #include <linux/ieee80211.h>
    #include <net/cfg80211.h>
#endif

#include "wlan_oid.h"

/*******************************************************************************
*                              C O N S T A N T S
********************************************************************************
*/

// (WirelessExtension) Private I/O Controls
#define IOC_P2P_CFG_DEVICE              (SIOCIWFIRSTPRIV+0)
#define IOC_P2P_PROVISION_COMPLETE      (SIOCIWFIRSTPRIV+2)
#define IOC_P2P_START_STOP_DISCOVERY    (SIOCIWFIRSTPRIV+4)
#define IOC_P2P_DISCOVERY_RESULTS       (SIOCIWFIRSTPRIV+5)
#define IOC_P2P_WSC_BEACON_PROBE_RSP_IE (SIOCIWFIRSTPRIV+6)
#define IOC_P2P_GO_WSC_IE               IOC_P2P_WSC_BEACON_PROBE_RSP_IE
#define IOC_P2P_CONNECT_DISCONNECT      (SIOCIWFIRSTPRIV+8)
#define IOC_P2P_PASSWORD_READY          (SIOCIWFIRSTPRIV+10)
//#define IOC_P2P_SET_PWR_MGMT_PARAM      (SIOCIWFIRSTPRIV+12)
#define IOC_P2P_SET_INT                 (SIOCIWFIRSTPRIV+12)
#define IOC_P2P_GET_STRUCT              (SIOCIWFIRSTPRIV+13)
#define IOC_P2P_SET_STRUCT              (SIOCIWFIRSTPRIV+14)
#define IOC_P2P_GET_REQ_DEVICE_INFO     (SIOCIWFIRSTPRIV+15)

#define PRIV_CMD_INT_P2P_SET            0

// IOC_P2P_PROVISION_COMPLETE (iw_point . flags)
#define P2P_PROVISIONING_SUCCESS        0
#define P2P_PROVISIONING_FAIL           1

// IOC_P2P_START_STOP_DISCOVERY (iw_point . flags)
#define P2P_STOP_DISCOVERY              0
#define P2P_START_DISCOVERY             1

// IOC_P2P_CONNECT_DISCONNECT (iw_point . flags)
#define P2P_CONNECT                     0
#define P2P_DISCONNECT                  1

// IOC_P2P_START_STOP_DISCOVERY (scan_type)
#define P2P_SCAN_FULL_AND_FIND          0
#define P2P_SCAN_FULL                   1
#define P2P_SCAN_SEARCH_AND_LISTEN      2
#define P2P_LISTEN                      3

// IOC_P2P_GET_STRUCT/IOC_P2P_SET_STRUCT
#define P2P_SEND_SD_RESPONSE            0
#define P2P_GET_SD_REQUEST              1
#define P2P_SEND_SD_REQUEST             2
#define P2P_GET_SD_RESPONSE             3
#define P2P_TERMINATE_SD_PHASE          4

/*******************************************************************************
*                             D A T A   T Y P E S
********************************************************************************
*/
/*----------------------------------------------------------------------------*/
/* Wireless Extension: Private I/O Control                                    */
/*----------------------------------------------------------------------------*/
typedef struct iw_p2p_cfg_device_type {
    void __user     *ssid;
    UINT_8          ssid_len;
    UINT_8          pri_device_type[8];
    UINT_8          snd_device_type[8];
    void __user     *device_name;
    UINT_8          device_name_len;
    UINT_8          intend;
    UINT_8          persistence;
    UINT_8          sec_mode;
    UINT_8          ch;
    UINT_8          ch_width; /* 0: 20 Mhz  1:20/40 Mhz auto */
    UINT_8          max_scb;
} IW_P2P_CFG_DEVICE_TYPE, *P_IW_P2P_CFG_DEVICE_TYPE;

typedef struct iw_p2p_hostapd_param {
    UINT_8  cmd;
    UINT_8  rsv[3];
    UINT_8  sta_addr[6];
    void __user   *data;
    UINT_16 	  len;
} IW_P2P_HOSTAPD_PARAM, *P_IW_P2P_HOSTAPD_PARAM;

typedef struct iw_p2p_req_device_type {
    UINT_8      scan_type;  /* 0: Full scan + Find
                             * 1: Full scan
                             * 2: Scan (Search +Listen)
                             * 3: Listen
                             * other : reserved
                             */
    UINT_8      pri_device_type[8];
    void __user *probe_req_ie;
    UINT_16     probe_req_len;
    void __user *probe_rsp_ie;
    UINT_16     probe_rsp_len;
} IW_P2P_REQ_DEVICE_TYPE, *P_IW_P2P_REQ_DEVICE_TYPE;

typedef struct iw_p2p_connect_device {
    UINT_8  sta_addr[6];
    UINT_8  p2pRole;        /* 0: P2P Device, 1:GC, 2: GO */
    UINT_8  needProvision;  /* 0: Don't needed provision, 1: doing the wsc provision first */
    UINT_8  authPeer;       /* 1: auth peer invitation request */
    UINT_8  intend_config_method; /* Request Peer Device used config method */
} IW_P2P_CONNECT_DEVICE, *P_IW_P2P_CONNECT_DEVICE;

typedef struct iw_p2p_password_ready {
    UINT_8      active_config_method;
    void __user *probe_req_ie;
    UINT_16     probe_req_len;
    void __user *probe_rsp_ie;
    UINT_16     probe_rsp_len;
} IW_P2P_PASSWORD_READY, *P_IW_P2P_PASSWORD_READY;

typedef struct iw_p2p_device_req {
    UINT_8      name[33];
    UINT_32     name_len;
    UINT_8      device_addr[6];
    UINT_8      device_type;
    INT_32      config_method;
    INT_32      active_config_method;
} IW_P2P_DEVICE_REQ, *P_IW_P2P_DEVICE_REQ;

typedef struct iw_p2p_transport_struct {
    UINT_32 u4CmdId;
    UINT_32 inBufferLength;
    UINT_32 outBufferLength;
    UINT_8  aucBuffer[16];
} IW_P2P_TRANSPORT_STRUCT, *P_IW_P2P_TRANSPORT_STRUCT;

// For Invitation
typedef struct iw_p2p_ioctl_invitation_struct {
    UINT_8 aucDeviceID[6];
    UINT_8 aucGroupID[6];  // BSSID
    UINT_8 aucSsid[32];
    UINT_32 u4SsidLen;
    UINT_8 ucReinvoke;
} IW_P2P_IOCTL_INVITATION_STRUCT, *P_IW_P2P_IOCTL_INVITATION_STRUCT;

typedef struct iw_p2p_ioctl_abort_invitation {
    UINT_8  dev_addr[6];
} IW_P2P_IOCTL_ABORT_INVITATION, *P_IW_P2P_IOCTL_ABORT_INVITATION;

typedef struct iw_p2p_ioctl_invitation_indicate {
    UINT_8  dev_addr[6];
	UINT_8  group_bssid[6];
    INT_32  config_method;     /* peer device supported config method */
    UINT_8  dev_name[32];      /* for reinvoke */
    UINT_32 name_len;
    UINT_8  operating_channel; /* for re-invoke, target operating channel */
    UINT_8  invitation_type;   /* invitation or re-invoke */
} IW_P2P_IOCTL_INVITATION_INDICATE, *P_IW_P2P_IOCTL_INVITATION_INDICATE;

typedef struct iw_p2p_ioctl_invitation_status {
    UINT_32 status_code;
} IW_P2P_IOCTL_INVITATION_STATUS, *P_IW_P2P_IOCTL_INVITATION_STATUS;

//For Formation
typedef struct iw_p2p_ioctl_start_formation {
   UINT_8  dev_addr[6];         /* bssid */
   UINT_8  role;                /* 0: P2P Device, 1:GC, 2: GO */
   UINT_8  needProvision;       /* 0: Don't needed provision, 1: doing the wsc provision first */
   UINT_8  auth;                /* 1: auth peer invitation request */
   UINT_8  config_method;       /* Request Peer Device used config method */
}IW_P2P_IOCTL_START_FORMATION, *P_IW_P2P_IOCTL_START_FORMATION;

/* SET_STRUCT / GET_STRUCT */
typedef enum _ENUM_P2P_CMD_ID_T {
    P2P_CMD_ID_SEND_SD_RESPONSE = 0,               /* 0x00 (Set) */
    P2P_CMD_ID_GET_SD_REQUEST,                     /* 0x01 (Get) */
    P2P_CMD_ID_SEND_SD_REQUEST,                    /* 0x02 (Set) */
    P2P_CMD_ID_GET_SD_RESPONSE,                    /* 0x03 (Get) */
    P2P_CMD_ID_TERMINATE_SD_PHASE,                 /* 0x04 (Set) */
#if 1 /* CFG_SUPPORT_ANTI_PIRACY */
    P2P_CMD_ID_SEC_CHECK,                          /* 0x05(Set) */
#endif
    P2P_CMD_ID_INVITATION,                         /* 0x06 (Set) */
    P2P_CMD_ID_INVITATION_INDICATE,                /* 0x07 (Get) */
    P2P_CMD_ID_INVITATION_STATUS,                  /* 0x08 (Get) */
    P2P_CMD_ID_INVITATION_ABORT,                   /* 0x09 (Set) */
    P2P_CMD_ID_START_FORMATION,                    /* 0x0A (Set) */
    P2P_CMD_ID_P2P_VERSION,                            /* 0x0B (Set/Get) */
    P2P_CMD_ID_GET_CH_LIST = 12,                   /* 0x0C (Get) */
    P2P_CMD_ID_GET_OP_CH = 14                      /* 0x0E (Get) */
} ENUM_P2P_CMD_ID_T, *P_ENUM_P2P_CMD_ID_T;

/* Service Discovery */
typedef struct iw_p2p_cmd_send_sd_response {
    PARAM_MAC_ADDRESS   rReceiverAddr;
    UINT_8              fgNeedTxDoneIndication;
    UINT_8              ucSeqNum;
    UINT_16	            u2PacketLength;
    UINT_8              aucPacketContent[0]; /*native 802.11*/
} IW_P2P_CMD_SEND_SD_RESPONSE, *P_IW_P2P_CMD_SEND_SD_RESPONSE;

typedef struct iw_p2p_cmd_get_sd_request {
    PARAM_MAC_ADDRESS   rTransmitterAddr;
    UINT_16	            u2PacketLength;
    UINT_8              aucPacketContent[0]; /*native 802.11*/
} IW_P2P_CMD_GET_SD_REQUEST, *P_IW_P2P_CMD_GET_SD_REQUEST;

typedef struct iw_p2p_cmd_send_service_discovery_request {
    PARAM_MAC_ADDRESS   rReceiverAddr;
    UINT_8              fgNeedTxDoneIndication;
    UINT_8              ucSeqNum;
    UINT_16             u2PacketLength;
    UINT_8              aucPacketContent[0]; /*native 802.11*/
} IW_P2P_CMD_SEND_SD_REQUEST, *P_IW_P2P_CMD_SEND_SD_REQUEST;

typedef struct iw_p2p_cmd_get_sd_response {
    PARAM_MAC_ADDRESS   rTransmitterAddr;
    UINT_16             u2PacketLength;
    UINT_8              aucPacketContent[0]; /*native 802.11*/
} IW_P2P_CMD_GET_SD_RESPONSE, *P_IW_P2P_CMD_GET_SD_RESPONSE;

typedef struct iw_p2p_cmd_terminate_sd_phase {
    PARAM_MAC_ADDRESS   rPeerAddr;
} IW_P2P_CMD_TERMINATE_SD_PHASE, *P_IW_P2P_CMD_TERMINATE_SD_PHASE;

typedef struct iw_p2p_version {
    UINT_32 u4Version;
} IW_P2P_VERSION, *P_IW_P2P_VERSION;

/*******************************************************************************
*                            P U B L I C   D A T A
********************************************************************************
*/

/*******************************************************************************
*                           P R I V A T E   D A T A
********************************************************************************
*/

/*******************************************************************************
*                                 M A C R O S
********************************************************************************
*/
/* Macros used for cfg80211 */
#define RATETAB_ENT(_rate, _rateid, _flags) \
    {                                       \
        .bitrate    = (_rate),              \
        .hw_value   = (_rateid),            \
        .flags      = (_flags),             \
    }

#define CHAN2G(_channel, _freq, _flags)             \
    {                                               \
        .band               = IEEE80211_BAND_2GHZ,  \
        .center_freq        = (_freq),              \
        .hw_value           = (_channel),           \
        .flags              = (_flags),             \
        .max_antenna_gain   = 0,                    \
        .max_power          = 30,                   \
    }

#define CHAN5G(_channel, _flags)                        \
    {                                                   \
        .band               = IEEE80211_BAND_5GHZ,      \
        .center_freq        = 5000 + (5 * (_channel)),  \
        .hw_value           = (_channel),               \
        .flags              = (_flags),                 \
        .max_antenna_gain   = 0,                        \
        .max_power          = 30,                       \
    }

/*******************************************************************************
*                  F U N C T I O N   D E C L A R A T I O N S
********************************************************************************
*/

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32) && (CFG_ENABLE_WIFI_DIRECT_CFG_80211 != 0)
int mtk_p2p_cfg80211_change_iface(
    struct wiphy *wiphy,
    struct net_device *ndev,
    enum nl80211_iftype type, u32 *flags,
    struct vif_params *params
    );

int mtk_p2p_cfg80211_add_key(
    struct wiphy *wiphy,
    struct net_device *ndev,
    u8 key_index,
    bool pairwise,
    const u8 *mac_addr,
    struct key_params *params
    );

int mtk_p2p_cfg80211_get_key(
    struct wiphy *wiphy,
    struct net_device *ndev,
    u8 key_index,
    bool pairwise,
    const u8 *mac_addr,
    void *cookie,
    void (*callback)(void *cookie, struct key_params*)
    );

int mtk_p2p_cfg80211_del_key(
    struct wiphy *wiphy,
    struct net_device *ndev,
    u8 key_index,
    bool pairwise,
    const u8 *mac_addr
    );

int
mtk_p2p_cfg80211_set_default_key(
    struct wiphy *wiphy,
    struct net_device *netdev,
    u8 key_index,
    bool unicast,
    bool multicast
    );

int mtk_p2p_cfg80211_get_station(
    struct wiphy *wiphy,
    struct net_device *ndev,
    u8 *mac,
    struct station_info *sinfo
    );

int mtk_p2p_cfg80211_set_wiphy_params(
    struct wiphy *wiphy,
    u32 changed
    );

int mtk_p2p_cfg80211_connect(
    struct wiphy *wiphy,
    struct net_device *dev,
    struct cfg80211_connect_params *sme
    );

int mtk_p2p_cfg80211_disconnect(
    struct wiphy *wiphy,
    struct net_device *dev,
    u16 reason_code
    );

int mtk_p2p_cfg80211_join_ibss(
    struct wiphy *wiphy,
    struct net_device *dev,
    struct cfg80211_ibss_params *params
    );

int mtk_p2p_cfg80211_leave_ibss(
    struct wiphy *wiphy,
    struct net_device *dev
    );

int mtk_p2p_cfg80211_set_power_mgmt(
    struct wiphy *wiphy,
    struct net_device *dev,
    bool enabled,
    int timeout
    );

int
mtk_p2p_cfg80211_change_bss(
    struct wiphy * wiphy,
    struct net_device * dev,
    struct bss_parameters * params
    );
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0)

int mtk_p2p_cfg80211_remain_on_channel(
	struct wiphy *wiphy,
    struct wireless_dev *wdev,
    struct ieee80211_channel *chan,
    unsigned int duration,
    u64 *cookie
    );

int mtk_p2p_cfg80211_scan(
	struct wiphy *wiphy,
    struct cfg80211_scan_request *request
    );

int mtk_p2p_cfg80211_cancel_remain_on_channel(
	struct wiphy *wiphy,
    struct wireless_dev *wdev,
    u64 cookie
    );

int mtk_p2p_cfg80211_set_txpower(
	struct wiphy *wiphy,
	struct wireless_dev *wdev,
    enum nl80211_tx_power_setting type,
    int mbm
    );

int mtk_p2p_cfg80211_get_txpower(
	struct wiphy *wiphy,
	struct wireless_dev *wdev,
    int *dbm
    );

#else
int
mtk_p2p_cfg80211_remain_on_channel(
    struct wiphy * wiphy,
    struct net_device * dev,
    struct ieee80211_channel * chan,
    enum nl80211_channel_type channel_type,
    unsigned int duration,
    u64 * cookie
    );

int mtk_p2p_cfg80211_scan(
    struct wiphy *wiphy,
    struct net_device *ndev,
    struct cfg80211_scan_request *request
    );

int
mtk_p2p_cfg80211_cancel_remain_on_channel(
    struct wiphy * wiphy,
    struct net_device * dev,
    u64 cookie
    );
int mtk_p2p_cfg80211_set_txpower(
    struct wiphy *wiphy,
    enum nl80211_tx_power_setting type,
    int mbm
    );

int mtk_p2p_cfg80211_get_txpower(
    struct wiphy *wiphy,
    int *dbm
    );

#endif

int
mtk_p2p_cfg80211_deauth(
    struct wiphy * wiphy,
    struct net_device * dev,
    struct cfg80211_deauth_request * req
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 2, 0)
    , void *cookie
#endif
    );

int
mtk_p2p_cfg80211_disassoc(
    struct wiphy * wiphy,
    struct net_device * dev,
    struct cfg80211_disassoc_request * req
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 2, 0)
    , void *cookie
#endif
    );
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 2, 0)

int
mtk_p2p_cfg80211_start_ap(
    struct wiphy *wiphy,
    struct net_device *dev,
    struct cfg80211_ap_settings *settings
    );

int
mtk_p2p_cfg80211_change_beacon(
    struct wiphy *wiphy,
    struct net_device *dev,
    struct cfg80211_beacon_data *info
    );

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0)

int mtk_p2p_cfg80211_mgmt_tx(
	struct wiphy *wiphy,
	struct wireless_dev *wdev,
    struct ieee80211_channel *chan,
    bool offchan,
    unsigned int wait,
    const u8 *buf,
    size_t len,
    bool no_cck,
    bool dont_wait_for_ack,
    u64 *cookie);
#else

int mtk_p2p_cfg80211_mgmt_tx(
    struct wiphy *wiphy,
    struct net_device *dev,
    struct ieee80211_channel *chan,
    bool offchan,
    enum nl80211_channel_type channel_type,
    bool channel_type_valid,
    unsigned int wait,
    const u8 *buf,
    size_t len,
    bool no_cck,
    bool dont_wait_for_ack,
    u64 *cookie);
#endif

#else
int
mtk_p2p_cfg80211_add_set_beacon(
    struct wiphy *wiphy,
    struct net_device *dev,
    struct beacon_parameters *info
    );

int
mtk_p2p_cfg80211_mgmt_tx(
    struct wiphy * wiphy,
    struct net_device * dev,
    struct ieee80211_channel * chan,
    bool offchan,
    enum nl80211_channel_type channel_type,
    bool channel_type_valid,
    unsigned int wait,
    const u8 * buf,
    size_t len,
    u64 *cookie
    );

#endif

int
mtk_p2p_cfg80211_stop_ap(
    struct wiphy * wiphy,
    struct net_device * dev
    );

int
mtk_p2p_cfg80211_del_station(
    struct wiphy * wiphy,
    struct net_device * dev,
    u8 * mac
    );

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0)
int mtk_p2p_cfg80211_set_channel(
	struct wiphy *wiphy,
    struct cfg80211_chan_def *chandef
   );

void mtk_p2p_cfg80211_mgmt_frame_register(
	struct wiphy *wiphy,
	struct wireless_dev *wdev,
	u16 frame_type,
	bool reg
	);

#else
int
mtk_p2p_cfg80211_set_channel(
    IN struct wiphy * wiphy,
    IN struct net_device * dev,
    IN struct ieee80211_channel * chan,
    IN enum nl80211_channel_type channel_type
    );

void
mtk_p2p_cfg80211_mgmt_frame_register(
    IN struct wiphy *wiphy,
    IN struct net_device *dev,
    IN u16 frame_type,
    IN bool reg
    );

#endif
int
mtk_p2p_cfg80211_set_bitrate_mask(
    IN struct wiphy *wiphy,
    IN struct net_device *dev,
    IN const u8 *peer,
    IN const struct cfg80211_bitrate_mask *mask
    );

#if CONFIG_NL80211_TESTMODE
int
mtk_p2p_cfg80211_testmode_cmd(
    IN struct wiphy *wiphy,
    IN void *data,
    IN int len
    );
int
mtk_p2p_cfg80211_testmode_p2p_sigma_pre_cmd(
    IN struct wiphy *wiphy,
    IN void *data,
    IN int len
    );
int
mtk_p2p_cfg80211_testmode_p2p_sigma_cmd(
    IN struct wiphy *wiphy,
    IN void *data,
    IN int len
    );

#if CFG_SUPPORT_WFD
int
mtk_p2p_cfg80211_testmode_wfd_update_cmd(
    IN struct wiphy *wiphy,
    IN void *data,
    IN int len
    );
#endif

int
mtk_p2p_cfg80211_testmode_hotspot_block_list_cmd(
    IN struct wiphy *wiphy,
    IN void *data,
    IN int len
    );
#else
    #error "Please ENABLE kernel config (CONFIG_NL80211_TESTMODE) to support Wi-Fi Direct"
#endif

#endif

/* I/O control handlers */

int
mtk_p2p_wext_get_priv (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_reconnect (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_set_auth (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_set_key (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_mlme_handler(
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_set_powermode(
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_get_powermode(
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

/* Private Wireless I/O Controls takes use of iw_handler */
int
mtk_p2p_wext_set_local_dev_info(
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_set_provision_complete(
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_start_stop_discovery(
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_discovery_results(
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_wsc_ie(
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_connect_disconnect(
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_password_ready(
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_request_dev_info(
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_invitation_indicate(
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_invitation_status(
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_set_pm_param (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_set_ps_profile (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_set_network_address (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_set_int (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

/* Private Wireless I/O Controls for IOC_SET_STRUCT/IOC_GET_STRUCT */
int
mtk_p2p_wext_set_struct (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_get_struct (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

/* IOC_SET_STRUCT/IOC_GET_STRUCT: Service Discovery */
int
mtk_p2p_wext_get_service_discovery_request (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_get_service_discovery_response (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_send_service_discovery_request (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_send_service_discovery_response (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_terminate_service_discovery_phase (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

#if CFG_SUPPORT_ANTI_PIRACY
int
mtk_p2p_wext_set_sec_check_request (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_get_sec_check_response (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );
#endif

int
mtk_p2p_wext_set_noa_param (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_set_oppps_param (
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_set_p2p_version(
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

int
mtk_p2p_wext_get_p2p_version(
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

void
mtk_p2p_wext_set_Multicastlist(
    IN P_GLUE_INFO_T prGlueInfo
    );

#if CFG_SUPPORT_P2P_RSSI_QUERY
int
mtk_p2p_wext_get_rssi(
    IN struct net_device *prDev,
    IN struct iw_request_info *info,
    IN OUT union iwreq_data *wrqu,
    IN OUT char *extra
    );

struct iw_statistics *
mtk_p2p_wext_get_wireless_stats(
    struct net_device *prDev
    );

#endif

int
mtk_p2p_wext_set_txpow(
    IN struct net_device *prDev,
    IN struct iw_request_info *prIwrInfo,
    IN OUT union iwreq_data *prTxPow,
    IN char *pcExtra
    );

/*******************************************************************************
*                              F U N C T I O N S
********************************************************************************
*/

#endif /* _GL_P2P_IOCTL_H */


Vova is playing a computer game. There are in total $$$n$$$ turns in the game and Vova really wants to play all of them. The initial charge of his laptop battery (i.e. the charge before the start of the game) is $$$k$$$.

During each turn Vova can choose what to do:

- If the current charge of his laptop battery is strictly greater than $$$a$$$, Vova can just play, and then the charge of his laptop battery will decrease by $$$a$$$;
- if the current charge of his laptop battery is strictly greater than $$$b$$$ ($$$b<a$$$), Vova can play and charge his laptop, and then the charge of his laptop battery will decrease by $$$b$$$;
- if the current charge of his laptop battery is less than or equal to $$$a$$$ and $$$b$$$ at the same time then Vova cannot do anything and loses the game.

Regardless of Vova's turns the charge of the laptop battery is always decreases.

Vova wants to complete the game (Vova can complete the game if after each of $$$n$$$ turns the charge of the laptop battery is strictly greater than $$$0$$$). Vova has to play exactly $$$n$$$ turns. Among all possible ways to complete the game, Vova wants to choose the one where the number of turns when he just plays (first type turn) is the maximum possible. It is possible that Vova cannot complete the game at all.

Your task is to find out the maximum possible number of turns Vova can just play (make the first type turn) or report that Vova cannot complete the game.

You have to answer $$$q$$$ independent queries.


I'm currently in my last year of my master's degree program "Physics of Complex System". I would like to write my master thesis about stochastic processes, but I'm having trouble in finding a good advisor with a good project within Europe, I'm planning of continuing my education with a Phd. Any advices?
Typically you get your advisor from your own institution. Your university makes the certificate indicating that you are "good". They put their reputation on the line by making that statement. So most universities want some quality control for at least the most central courses, like a thesis.
Also, think of this from the point of view of the advisor. Advising students is work, often enjoyable work, but still work. We usually get assigned students or a number of students we have to take, or we have to teach less other courses if we take x students, or in some other way get told by the department to do this for our own students. If we take outside students, that just adds to our workload, and is not compensated. However, enjoyable advising students is, I can think of even more enjoyable things to do, like playing with my own kids.


Nothing you can do easily and not with vanilla AE, anyway. The example you posted is a fluid simulation from a 3D program (though a very poorly tweaked one) and that's pretty much the answer here: If you want the exact look, you have to invoke those expensive tools and programs. Otherwise some of it may be possible to fake using layers upon layers and complex particle systems like Stardust, but even then it will be complicated and require long tweaking as well as long rendering due to massive amounts of particles and simulations. Such stuff simply isn't something where you push a button and it looks good.
It depends on how you are generating the particles. Some particle systems have walls that you can set up to make particle bounce, some have obstructions you can create with masks or the alpha channels of other layers. Sometimes you need two layers with particles so you can deflect the particles from one emitter in one direction and the other emitter in a different direction.
Please tell us what tools you are using and we can give you more advice. If you are fortunate enough to have Trapcode Particular you can do some amazing things.


User ainta decided to make a new instant messenger called "aintalk". With aintalk, each user can chat with other people. User ainta made the prototype of some functions to implement this thing.

1. login(u): User u logins into aintalk and becomes online.
2. logout(u): User u logouts and becomes offline.
3. add_friend(u, v): User u and user v become friends. It means, u and v can talk with each other. The friendship is bidirectional.
4. del_friend(u, v): Unfriend user u and user v. It means, u and v cannot talk with each other from then.
5. count_online_friends(u): The function returns the number of friends of user u who are online at the moment.

Because the messenger is being tested by some users numbered from 1 to n, there is no register method. This means, at the beginning, some users may be online, and some users may have friends.

User ainta is going to make these functions, but before making the messenger public, he wants to know whether he is correct. Help ainta verify his code.


//////////////////////////////////////////////////////////////////////////////////////////
//
//    Arduino library for the MAX30205 body temperature sensor breakout board
//
//    Author: Ashwin Whitchurch
//    Copyright (c) 2018 ProtoCentral
//
//    This software is licensed under the MIT License(http://opensource.org/licenses/MIT).
//
//   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
//   NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
//   IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
//   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
//   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//   For information on how to use, visit https://github.com/protocentral/ProtoCentral_MAX30205
/////////////////////////////////////////////////////////////////////////////////////////

#define MAX30205_ADDRESS1        0x49  // 8bit address converted to 7bit
#define MAX30205_ADDRESS2        0x48  // 8bit address converted to 7bit

// Registers
#define MAX30205_TEMPERATURE    0x00  //  get temperature ,Read only
#define MAX30205_CONFIGURATION  0x01  //
#define MAX30205_THYST          0x02  //
#define MAX30205_TOS            0x03  //

#include <drivers/i2c.h>

typedef unsigned char uint8_t;

typedef enum{   	//For configuration registers
  SHUTDOWN,    		// shutdwon mode to reduce power consumption <3.5uA
  COMPARATOR,    	// Bit 0 = operate OS in comparator mode, 1= INTERRUPT MODE
  OS_POLARITY,    	// Polarity bit ;Bit 0 = Active low output, Bit 1 = Active high
  FAULT_QUEUE_0,    // Fault indication bits
  FAULT_QUEUE_1,    // Fault indication bits
  DATA_FORMAT,      //Data Format
  TIME_OUT,          //Time out
  ONE_SHOT           //1= One shot, 0 = Continuos
}configuration;

class MAX30205 {
public:

  MAX30205(const device *i2c_dev);

  float temperature = 0;      // Last temperature
  uint8_t sensorAddress = MAX30205_ADDRESS1;
  void  shutdown(void);   // Instructs device to power-save
  void  printRegisters(void); // Dumps contents of registers for debug
  void begin(void);
  float getTemperature(void);
  bool scanAvailableSensors(void);

private:
  const device *i2c_dev;

  void    I2CwriteByte(uint8_t address, uint8_t subAddress, uint8_t data);
  uint8_t I2CreadByte(uint8_t address, uint8_t subAddress);
  void    I2CreadBytes(uint8_t address, uint8_t subAddress, uint8_t * dest, uint8_t count);
};


Here you can see all the Azure PowerShell scripts and it’s usage. I would keep updating the page with more resources as and when I come across.
1.To Connect to the Azure Cloud Subscription. Once you get the popups enter the Credentials.
2. List the Azure subscription environment details.
3. List all the VMs under the subscription.
4. To get a detailed info on the VMs
Get-AzureRmVM | Select *
5. Get all locations and the supported resource providers for each location.
Get-AzureRmLocation | ft -AutoSize
6. Once you know the location, you can use below command to check the VM Sizes provided in a specific region.
Get-AzureRmVMSize -Location westus
7. List all the Web Apps.


How do I turn on CloudWatch Logs for troubleshooting my API Gateway REST API or WebSocket API?
I need to debug errors with an Amazon API Gateway REST API or WebSocket API that I'm developing. How do I turn on logging to troubleshoot my API?
To troubleshoot an API Gateway REST API or WebSocket API, turn on execution logging and access logging using Amazon CloudWatch Logs.
Note: HTTP APIs currently support access logging only, and logging setup is different for these APIs. For more information, see Configuring logging for an HTTP API.
Execution logs contain information that you can use to identify and troubleshoot most API errors. For example:
- The requests that your API receives
- The integration backend responses from your API
- The response provided by AWS Lambda authorizers
- The requestId for AWS integration endpoints
- Information on whether a provided API key was authorized
Access logs contain details about who accessed your API and how they accessed it. You can also use the logs for troubleshooting API errors. For more information about each type of logging, see CloudWatch log formats for API Gateway.
Create an IAM role for logging to CloudWatch
1. In the AWS Identity and Access Management (IAM) console, in the navigation pane, choose Roles.
2. On the Roles pane, choose Create role.
3. On the Create role page, do the following:
For Trusted entity type, choose AWS Service.
For use case, choose API Gateway.
Choose the API Gateway radio button.
4. Under Permissions Policies, note that the AWS managed policy AmazonAPIGatewayPushToCloudWatchLogs is selected by default. The policy has all the required permissions.
5. Choose Next.
6. Under Name, review and create, do the following:
For Role name, enter a name for the role.
(Optional) For Role description, edit the description to your preferences.
(Optional) Add tags.
Choose Create role.
7. On the Roles pane, in the search bar, enter the name of the role that you created. Then, choose the role from the search results.
8. On the Summary pane, copy the Role ARN. You need this Amazon Resource Name (ARN) in the next section.
For more information, see Permissions for CloudWatch logging.
Add the IAM role in the API Gateway console
Note: If you're developing multiple APIs across different AWS Regions, complete these steps in each Region.
1. In the API Gateway console, on the APIs pane, choose the name of an API that you created. This is either a REST API or a WebSocket API (not an HTTP API).
2. In the left navigation pane, at the bottom, below the Client Certificates section, choose Settings.
3. Under Settings, for CloudWatch log role ARN, paste the IAM role ARN that you copied.
4. Choose Save.
Note: The console doesn't confirm that the ARN is saved.
Turn on logging for your API and stage
1. In the API Gateway console, on the APIs pane, choose the name of an API that you created.
2. In the left navigation pane, choose Stage. Then, select your desired stage name.
3. Choose the Logs/Tracing tab.
4. On the Logs/Tracing tab, under CloudWatch Settings, do the following to turn on execution logging:
Choose the Enable CloudWatch Logs check box.
For Log level, choose INFO to generate execution logs for all requests. Or, choose ERROR to generate execution logs only for requests to your API that result in an error.
For REST APIs, choose the Log full requests/responses data check box. Or, for WebSocket APIs, choose the Log full message data check box.
5. Under Custom Access Logging, do the following to turn on access logging:
Choose the Enable Access Logging check box.
For Access Log Destination ARN, enter the ARN of an Amazon Kinesis Data Firehose (this is only supported in REST APIs) or a CloudWatch log group.
Enter a Log Format. For guidance, choose CLF, JSON, XML, or CSV to see an example in that format.
6. Choose Save Changes.
Note: The console doesn't confirm that settings are saved.
For more information, see Set up CloudWatch API logging using the API Gateway console.
Test your logging setup
1. Send a new request to your API using your client application or a tool such as the Postman app or wscat (for WebSocket APIs).
2. In the CloudWatch console, in the left navigation pane, under Logs, choose Log Groups.
3. In the list of Log Groups, choose the log group of the API that you're debugging.
For REST APIs, the log group's name is in the following format: API-Gateway-Execution-Logs_apiId/stageName.
For WebSocket APIs, the log group's name is in the following format: /aws/apigateway/apiId/stageName.
Note: The access logs are located in the log group whose ARN that you specified when you turned on access logging.
4. In the list of Log Streams, choose the logs stream with the latest Last Event Time. This selection will allow you to see messages with the execution or access details of your request.
For more information, see View API Gateway log events in the CloudWatch console.
Setting up CloudWatch logging for a REST API in API Gateway
API Gateway mapping template and access logging variable reference
Monitoring REST API execution with Amazon CloudWatch metrics
- OFICIAL DE AWSActualizada hace 7 meses
- OFICIAL DE AWSActualizada hace 6 meses
- OFICIAL DE AWSActualizada hace 9 meses


Related European Activities
ESCAPE stands for Energy-efficient Scalable Algorithms for Weather Prediction at Exascale. The project will develop world-class, extreme-scale computing capabilities for European operational numerical weather prediction and future climate models. The biggest challenge for state-of-the art NWP arises from the need to simulate complex physical phenomena within tight production schedules.
PRIMAVERA stands for "Process-based climate simulation: Advances in high-resolution modelling and European climate risk assessment". It is a European Union Horizon 2020 project which aims to develop a new generation of advanced and well-evaluated high-resolution global climate models, capable of simulating and predicting regional climate with unprecedented fidelity, for the benefit of governments, business and society in general.
The Performance Optimisation and Productivity (POP) Centre of Excellence in Computing Applications provides performance optimisation and productivity services for academic and industrial code(s) in all domains.
The Energy oriented Centre of Excellence in computing applications (EoCoE: read as "Echo") uses the tremendous potential offered by the ever-growing computing infrastructure to foster and accelerate the European transition to a reliable and low carbon energy supply using HPC.
The CoeGSS project aims at empowering the community of analysts addressing global challenges through high-performance computing and data analysis. In particular, the project will develop an HPC-based framework to generate synthetic information systems for tackling global challenges.
IS-ENES2 is the second phase project of the distributed e-infrastructure of models, model data and metadata of the European Network for Earth System Modelling (ENES). It gathers together the European modelling community working on understanding and predicting climate variability and change. IS-ENES2 combines expertise in climate modelling, computational science, data management and climate impacts.
ETP4HPC is the European Technology Platform (ETP) in the area of High-Performance Computing (HPC). It is an industry-led think-tank comprising of European HPC technology stakeholders: technology vendors, research centres and end-users. The main objective of ETP4HPC is to define research priorities and action plans in the area of HPC technology provision (i.e. the provision of supercomputing systems). ETP4HPC issues and maintains a Strategic Research Agenda as a mechanism to help the European Commission define the contents of the HPC Technology Work Programmes.
The European Extreme Data & Computing Initiative (EXDCI) objective is to support the development and implementation of a common strategy for the European HPC Ecosystem. The two most significant HPC bodies in Europe, PRACE and ETP4HPC, join their expertise in this 30-month project. EXDCI aims to support the road-mapping, strategy-making and performance-monitoring activities of the ecosystem.


is work fine another on the windows ilke xp to 8.1 is fast ilke detected somethink ilke that this hacks is detected 100% but can work is the think is mean good
we dont care got bannd for lossing id for anythink right...
- - - Updated - - -
Originally Posted by fifdina99
why fast hack detected?
I on BlackShot then at character hack detected?
the blackshot hacks in pass 5 hours is 100% detected but is work fine sometime so good lucky..


Adding rows to a room
- Click the Generate Rows icon in the room design toolbar and follow the instructions in the Generate Rows wizard to get a quick standard row layout from which to start.
- Or drag and drop individual rows from the Genomes pane into the layout and flip or resize as needed to get a customized row layout.
Adding other elements to a room
Adding room fixtures such as gaps and block, inner walls, cages, doors and windows allows you to create a more accurate model of the data center, making it easy to navigate the room.
- Click the Genome Library icon and double-click Room Fixture to add the folder and elements to the Genomes pane.
- Drag the element icons from the Genomes pane into position in the room layout.
- Right-click an element in the layout and select Properties to edit e.g. name, size, or type properties, or use the icons in the room design toolbar for editing.
Gaps and blocks
Gaps and blocks represent areas in the room layout in which equipment cannot be placed.
A gap is a section over which cables and cooling lines can be routed (such as a walkway or ramp).
A block is a section over which cables and cooling lines cannot be routed (such as a support column).
Walls and cages
Inner walls are represented as solid, mesh, or glass. You can copy properties from one wall to another or set a default wall type to be applied to all new walls.
Doors are represented as slide or swing doors. Swing doors are color-coded in the layout based on security type.


Game studio "DbZ Games" wants to introduce another map in their popular game "Valiant". This time, the map named "Panvel" will be based on the city of Mumbai.

Mumbai can be represented as $$$n \times m$$$ cellular grid. Each cell $$$(i, j)$$$ ($$$1 \le i \le n$$$; $$$1 \le j \le m$$$) of the grid is occupied by a cuboid building of height $$$a_{i,j}$$$.

This time, DbZ Games want to make a map that has perfect vertical gameplay. That's why they want to choose an $$$l \times l$$$ square inside Mumbai, such that each building inside the square has a height of at least $$$l$$$.

Can you help DbZ Games find such a square of the maximum possible size $$$l$$$?


You have a statistic of price changes for one product represented as an array of $$$n$$$ positive integers $$$p_0, p_1, \dots, p_{n - 1}$$$, where $$$p_0$$$ is the initial price of the product and $$$p_i$$$ is how the price was increased during the $$$i$$$-th month.

Using these price changes you are asked to calculate the inflation coefficients for each month as the ratio of current price increase $$$p_i$$$ to the price at the start of this month $$$(p_0 + p_1 + \dots + p_{i - 1})$$$.

Your boss said you clearly that the inflation coefficients must not exceed $$$k$$$ %, so you decided to increase some values $$$p_i$$$ in such a way, that all $$$p_i$$$ remain integers and the inflation coefficients for each month don't exceed $$$k$$$ %.

You know, that the bigger changes — the more obvious cheating. That's why you need to minimize the total sum of changes.

What's the minimum total sum of changes you need to make all inflation coefficients not more than $$$k$$$ %?


Can we derive Gk ἐυπάτωρ 'having a good father' straight from an IE root? The root would be a so-called nominal composite, that is, a noun formed from two elements, in this case an adverb and a noun. The first element of the compound is unproblematic *h1esu; it is the second part that may cause some troubles. The second nominal element is obviously derived from *ph2-tér-s (nom. sing), which is a standard hysterkinetic noun. The question becomes, then, can we derive an amphikinetic noun from a hysterokinetic one? The second element of the nominal composite would have to be *pá-tōr-s. The accent shift is interesting. From the root *ph2-tér-s, two methods of derivation are possible. First, the root with a syllabic laryngeal would have to hold the accent, so we would have *ph2-tōr-s. There are apparently roots which have accented syllabic resonants, but the roots (the ones for 'wolf' and 'bear') are a bit sketchy to being with, and to my knowledge there are no roots which have an accented syllabic laryngeal. So this, to me, seems unlikely. The second possibility is then the best one: namely that the accent shift occured after the 'loss' of the laryngeal and the creation of the 'a' vowel. Thus, in my view, we would have
*ph2-tér-s > *pa-tér-s > *h1esu-pá-tōr-s >ἐυ-πάτωρ.
*ph2-tér-s > *ph2-tōr-s [with the accent on the root] > *h1esu-pá-tōr-s >ἐυ-πάτωρ.
Given all of this, it seems that whether ἐυπάτωρ comes from a 'true' IE root hinges upon when the shift from *h2 > α happened, which presumably was a post-IE-pre-Greek development. Thus, I would argue that the Greek word cannot be derived straight from an IE root, given that the shift from *h2 > a is a prerequisite of the derivation of the nominal element in the compound. To be fair, though, nominal composites such as this need much more work. Perhaps it's a future project for me.


Egor wants to achieve a rating of 1600 points on the well-known chess portal ChessForces and he needs your help!

Before you start solving the problem, Egor wants to remind you how the chess pieces move. Chess rook moves along straight lines up and down, left and right, as many squares as it wants. And when it wants, it can stop. The queen walks in all directions vertically and diagonally at any distance. You can see the examples below.

To reach the goal, Egor should research the next topic:

There is an $$$N \times N$$$ board. Each cell of the board has a number from $$$1$$$ to $$$N ^ 2$$$ in it and numbers in all cells are distinct.

In the beginning, some chess figure stands in the cell with the number $$$1$$$. Note that this cell is already considered as visited. After that every move is determined by the following rules:

1. Among all not visited yet cells to which the figure can get in one move, it goes to the cell that has minimal number.
2. If all accessible cells were already visited and some cells are not yet visited, then the figure is teleported to the not visited cell that has minimal number. If this step happens, the piece pays a fee of $$$1$$$ vun.
3. If all cells are already visited, the process is stopped.

Egor should find an $$$N \times N$$$ board on which the rook pays strictly less vuns than the queen during the round with this numbering. Help him to find such $$$N \times N$$$ numbered board, or tell that it doesn't exist.


There's nothing that prohibits you from continuing to test a REST API manually when it uses OAuth authentication. OAuth simply requires that you send additional parameters: first that you negotiate the OAuth dance to get a request token and exchange it for an access token and then that each request has the necessary OAuth parameters (
oauth_nonce). You'd need to use a separate tool to do the signing (unless the product you're testing is willing to use
PLAINTEXT as the signature method), but you could simply copy all of these values in manually to your current manual tool.
If that sounds like a lot of work, you're right! I think this is a good time to switch to automated testing. Libraries exist for most languages to consume OAuth services programmatically and that would handle all of those parameters and signing for you. You could build a generic tool that let a manual tester specify URLs and parameters by hand, or go farther and write something that did all the generation and validation automatically.
Update: for doing some exploratory testing from the command line, it would certainly be helpful to have a
curl-like tool that handles some of the OAuth paramaters and signing. Check out oauth-proxy which may work for you -- it's intended exactly for exploring APIs on the command line. Or you may find that for your particular explorations, you want to build a script around oauth-proxy or a tool on top of one of the many OAuth libraries for different languages.


Political Memory (Memopol) is a toolbox designed to help citizens follow the activity and voting records of their representatives in order to help them influence decision and policy-making.
Le bot qui s'occupe d'ajouter les urls données par les bénévoles sur IRC dans la base de données des articles à "rp-iser"
Campaign web site to monitor net neutrality violations made by operators.
Blog about Memopol and its news. In Pelican.
Political Memory is a tool designed by La Quadrature du Net to help citizens reach their representatives and track their voting records on issues related to fundamental freedoms online.


And for dvd production, i use professional quality tools only because I am an obnoxiously picky person and like to complicate my life needlessly.
And we like that about you. So what are you using for DVD burning/producing?
Well, last time I played around with it, DVDfab was the acclaimed recommendation, and I liked it also. It's flexible and powerful, perhaps a little complicated, but it's a complicated thing to make dvd menus and stuff if you want to customize every little thing.
I found the most annoying part of the whole process converting the videos into the proper dvd format (video_ts, etc.). It takes a long time, it's complicated, huge files, very annoying. It is this precise reason why i don't really do this often...it takes too long.
In my opinion, dvd's and their format is old hat. Time to move on. I like mkv files because mkv has a lot of features. It would be cool to be able to purchase an mkv file eventually. So currently I'm more interested in mkv creation tools vs dvd creation tools. I don't think you can have menus in mkv files, but you can have chapters within the files and multiple audio streams and subs. So in one file, you can shove in a whole bunch of stuff. If I were a producer, I'd look into suites that can output mkv files with lots of customizeable options.
For video editing, after trying a bunch of suites, i settled on sony vegas. Haven't tried outputting to mkv yet. This is off topic...


You are given a complete undirected graph with n vertices. A number ai is assigned to each vertex, and the weight of an edge between vertices i and j is equal to ai xor aj.

Calculate the weight of the minimum spanning tree in this graph.


I’ve recently started building games for Gambit.com. We build turn-based games and you can gamble for Bitcoins, that’s the general idea.
When writing turn-based browser games, most of the client-side programming consists of handling events – player clicked on something, placed a figure on the board, dropped a tile somewhere.
So you need to implement the game logic in the GUI. Here’s a real world requirement from the Dominoes game I’m building:
- A player clicks on a tile from his hand
- Next he clicks on a open end of the board in order to place the tile
- If it’s a valid move, the tile gets placed, the server gets notified etc.
So you say “okay, simple enough” and start writing code. The first would be to catch the
click event and update
model.selectedTile. You write a handler:
1 2 3 4
This is a pseudo-Backbone code, but you get the idea.
Now you want to put a border around the selected tile. Where do you put that code? Well, in the handlers of course. Let’s just add:
1 2 3 4 5 6
Wait. Now, what’s this handler doing? It’s catching the ‘click’ event and it’s updating the view. You’re in trouble.
Why should a click handler be even aware of the looks of the game? It’s an innocent line of code – you might say. Okay.
Now let’s tell the server the human player clicked an element, just for analytics sake.
Where do we put that code? In the click handler of course.
1 2 3 4 5 6 7 8
And where do we handle the error of the call, if any?
Well in the click handler of course. The system is quickly and surely turning into chaos.
What should an event handler do, what’s it’s job? Well:
- Catch the event
- Do some data transformation possibly (like taking the ‘data-tile-value’ out of the currentTarget)
- Perhaps update the model – and finally
- Notify the rest of the system that there’s been an update
1 2 3 4 5 6 7
Now, want to highlight the tile? Want to notify the server. Sure:
Now that the
this.highlight function is separated and does exactly one thing, you can call it in case of, lets say, you want to mark only a valid tile in the players hand.
Watch out for
- Event handlers that do more then the necessary model updates and data transformations
- Functions (event handlers included) that do two things or more things at once, like highlighting a tile and sending the server an update
- Event handlers that know too much about the GUI or the model
Try to do
- Emit another event at the end of the current events’ handler; chain logic in this way


//*******************************************************************************
// COPYRIGHT NOTES
// ---------------
// This is a part of the BCGControlBar Library
// Copyright (C) 1998-2012 BCGSoft Ltd.
// All rights reserved.
//
// This source code can be used, distributed or modified
// only under terms and conditions
// of the accompanying license agreement.
//*******************************************************************************

// BCGVisualManagerXP.h: interface for the CBCGPVisualManagerXP class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_BCGPVISUALMANAGERXP_H__062013FA_7440_4CEC_AA78_67893D195FFA__INCLUDED_)
#define AFX_BCGPVISUALMANAGERXP_H__062013FA_7440_4CEC_AA78_67893D195FFA__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "BCGCBPro.h"
#include "BCGPVisualManager.h"
#include "MenuImages.h"

class CBCGPStatusBar;
class CBCGPBaseControlBar;

class BCGCBPRODLLEXPORT CBCGPVisualManagerXP : public CBCGPVisualManager
{
	DECLARE_DYNCREATE(CBCGPVisualManagerXP)

protected:
	CBCGPVisualManagerXP(BOOL bIsTemporary = FALSE);

public:
	virtual ~CBCGPVisualManagerXP();

protected:
	virtual void OnUpdateSystemColors ();

	virtual void OnDrawBarGripper (CDC* pDC, CRect rectGripper, BOOL bHorz, CBCGPBaseControlBar* pBar);
	virtual void OnFillBarBackground (CDC* pDC, CBCGPBaseControlBar* pBar,
									CRect rectClient, CRect rectClip,
									BOOL bNCArea = FALSE);
	virtual void OnDrawBarBorder (CDC* pDC, CBCGPBaseControlBar* pBar, CRect& rect);
	virtual void OnDrawMenuBorder (CDC* pDC, CBCGPPopupMenu* pMenu, CRect rect);
	virtual void OnDrawMenuShadow (CDC* pDC, const CRect& rectClient, const CRect& rectExclude,
									int nDepth,  int iMinBrightness,  int iMaxBrightness,
									CBitmap* pBmpSaveBottom,  CBitmap* pBmpSaveRight,
									BOOL bRTL);
	virtual void OnDrawSeparator (CDC* pDC, CBCGPBaseControlBar* pBar, CRect rect, BOOL bIsHoriz);
	virtual COLORREF OnDrawMenuLabel (CDC* pDC, CRect rect);

	virtual void OnFillButtonInterior (CDC* pDC,
		CBCGPToolbarButton* pButton, CRect rect, CBCGPVisualManager::BCGBUTTON_STATE state);

	virtual void OnDrawButtonBorder (CDC* pDC,
		CBCGPToolbarButton* pButton, CRect rect, CBCGPVisualManager::BCGBUTTON_STATE state);

	virtual void OnHighlightMenuItem (CDC*pDC, CBCGPToolbarMenuButton* pButton,
		CRect rect, COLORREF& clrText);
	virtual COLORREF GetHighlightedMenuItemTextColor (CBCGPToolbarMenuButton* pButton);
	virtual void OnHighlightRarelyUsedMenuItems (CDC* pDC, CRect rectRarelyUsed);
	virtual void OnHighlightQuickCustomizeMenuButton (CDC* pDC, CBCGPToolbarMenuButton* pButton, CRect rect);
	virtual BOOL IsHighlightWholeMenuItem ()	{	return TRUE;	}

	virtual void OnEraseTabsArea (CDC* pDC, CRect rect, const CBCGPBaseTabWnd* pTabWnd);
	virtual void OnDrawTab (CDC* pDC, CRect rectTab,
							int iTab, BOOL bIsActive, const CBCGPBaseTabWnd* pTabWnd);
	virtual void OnFillTab (CDC* pDC, CRect rectFill, CBrush* pbrFill, int iTab, BOOL bIsActive, const CBCGPBaseTabWnd* pTabWnd);

	virtual void OnDrawTabCloseButton (CDC* pDC, CRect rect,
											   const CBCGPBaseTabWnd* pTabWnd,
											   BOOL bIsHighlighted,
											   BOOL bIsPressed,
											   BOOL bIsDisabled);
	virtual void OnEraseTabsButton (CDC* pDC, CRect rect, CBCGPButton* pButton,
									CBCGPBaseTabWnd* pWndTab);
	virtual void OnDrawTabsButtonBorder (CDC* pDC, CRect& rect,
										CBCGPButton* pButton, UINT uiState, CBCGPBaseTabWnd* pWndTab);

	virtual COLORREF OnDrawControlBarCaption (CDC* pDC, CBCGPDockingControlBar* pBar,
		BOOL bActive, CRect rectCaption, CRect rectButtons);

	virtual void OnDrawCaptionButton (CDC* pDC, CBCGPCaptionButton* pButton,
									BOOL bActive, BOOL bHorz, BOOL bMaximized, BOOL bDisabled,
									int nImageID = -1);
	virtual void OnDrawCaptionButtonIcon (CDC* pDC,
											CBCGPCaptionButton* pButton,
											CBCGPMenuImages::IMAGES_IDS id,
											BOOL bActive, BOOL bDisabled,
											CPoint ptImage);

	virtual void OnDrawDockingBarScrollButton(CDC* pDC, CBCGPDockingBarScrollButton* pButton);

	virtual void OnDrawComboDropButton (CDC* pDC, CRect rect,
										BOOL bDisabled,
										BOOL bIsDropped,
										BOOL bIsHighlighted,
										CBCGPToolbarComboBoxButton* pButton);
	virtual void OnDrawComboBorder (CDC* pDC, CRect rect,
										BOOL bDisabled,
										BOOL bIsDropped,
										BOOL bIsHighlighted,
										CBCGPToolbarComboBoxButton* pButton);
	virtual void OnDrawEditBorder (CDC* pDC, CRect rect,
										BOOL bDisabled,
										BOOL bIsHighlighted,
										CBCGPToolbarEditBoxButton* pButton);

	virtual COLORREF GetToolbarButtonTextColor (CBCGPToolbarButton* pButton,
												CBCGPVisualManager::BCGBUTTON_STATE state);
	virtual BOOL IsToolBarButtonDefaultBackground (CBCGPToolbarButton* pButton,
												CBCGPVisualManager::BCGBUTTON_STATE state);

	virtual void OnDrawTearOffCaption (CDC* pDC, CRect rect, BOOL bIsActive);
	virtual void OnDrawMenuResizeBar (CDC* pDC, CRect rect, int nResizeFlags);
	virtual void OnDrawMenuScrollButton (CDC* pDC, CRect rect, BOOL bIsScrollDown,
										BOOL bIsHighlited, BOOL bIsPressed, BOOL bIsDisabled);

	virtual void GetCalendarColors (const CBCGPCalendar* pCalendar,
				   CBCGPCalendarColors& colors);
	virtual void OnDrawSpinButtons (CDC* pDC, CRect rectSpin, int nState, BOOL bOrientation, CBCGPSpinButtonCtrl* pSpinCtrl);
	virtual void OnFillSpinButton (CDC* pDC, CBCGPSpinButtonCtrl* pSpinCtrl, CRect rect, BOOL bDisabled);

	virtual COLORREF OnFillCommandsListBackground (CDC* pDC, CRect rect, BOOL bIsSelected = FALSE);
	virtual void OnDrawMenuArrowOnCustomizeList (CDC* pDC, CRect rectCommand, BOOL bSelected);

	virtual void OnDrawMenuSystemButton (CDC* pDC, CRect rect, UINT uiSystemCommand,
										UINT nStyle, BOOL bHighlight);
	virtual void OnDrawStatusBarPaneBorder (CDC* pDC, CBCGPStatusBar* pBar,
					CRect rectPane, UINT uiID, UINT nStyle);

	virtual int GetMenuImageMargin () const
	{
		return 3;
	}

	virtual int GetPopupMenuGap () const
	{
		return 0;
	}

	virtual void OnDrawButtonSeparator (CDC* pDC,
		CBCGPToolbarButton* pButton, CRect rect, CBCGPVisualManager::BCGBUTTON_STATE state,
		BOOL bHorz);

	virtual COLORREF OnFillMiniFrameCaption (CDC* pDC, CRect rectCaption,
											CBCGPMiniFrameWnd* pFrameWnd,
											BOOL bActive);
	virtual void OnDrawMiniFrameBorder (CDC* pDC, CBCGPMiniFrameWnd* pFrameWnd,
										CRect rectBorder, CRect rectBorderSize);
	virtual void OnDrawFloatingToolbarBorder (	CDC* pDC, CBCGPBaseToolBar* pToolBar,
												CRect rectBorder, CRect rectBorderSize);

	virtual COLORREF GetToolbarHighlightColor ()
	{
		return m_clrHighlight;
	}

	virtual COLORREF GetHighlightedColor(UINT nType);

	virtual COLORREF OnFillCaptionBarButton (CDC* pDC, CBCGPCaptionBar* pBar,
											CRect rect, BOOL bIsPressed, BOOL bIsHighlighted,
											BOOL bIsDisabled, BOOL bHasDropDownArrow,
											BOOL bIsSysButton);
	virtual void OnDrawCaptionBarButtonBorder (CDC* pDC, CBCGPCaptionBar* pBar,
											CRect rect, BOOL bIsPressed, BOOL bIsHighlighted,
											BOOL bIsDisabled, BOOL bHasDropDownArrow,
											BOOL bIsSysButton);
	virtual void OnDrawCaptionBarInfoArea (CDC* pDC, CBCGPCaptionBar* pBar, CRect rect);

#ifndef BCGP_EXCLUDE_PROP_LIST
	virtual COLORREF GetPropListGroupColor (CBCGPPropList* pPropList);
	virtual COLORREF GetPropListGroupTextColor (CBCGPPropList* pPropList);
#endif

	// Tasks pane:
#ifndef BCGP_EXCLUDE_TASK_PANE
	virtual void OnDrawTasksGroupCaption(CDC* pDC, CBCGPTasksGroup* pGroup,
										BOOL bIsHighlighted = FALSE, BOOL bIsSelected = FALSE,
										BOOL bCanCollapse = FALSE);

	virtual void OnFillTasksGroupInterior(CDC* pDC, CRect rect, BOOL bSpecial = FALSE);
	virtual void OnDrawTasksGroupAreaBorder(CDC* pDC, CRect rect, BOOL bSpecial = FALSE,
											BOOL bNoTitle = FALSE);
	virtual void OnDrawTask(CDC* pDC, CBCGPTask* pTask, CImageList* pIcons,
							BOOL bIsHighlighted = FALSE, BOOL bIsSelected = FALSE);

	virtual void OnDrawScrollButtons(CDC* pDC, const CRect& rect, const int nBorderSize,
									int iImage, BOOL bHilited);
#endif // BCGP_EXCLUDE_TASK_PANE

	BOOL IsLook2000Allowed () const
	{
		return FALSE;
	}

	virtual void OnDrawSplitterBorder (CDC* pDC, CBCGPSplitterWnd* pSplitterWnd, CRect rect);
	virtual void OnDrawSplitterBox (CDC* pDC, CBCGPSplitterWnd* pSplitterWnd, CRect& rect);

	// Calculator:
	virtual BOOL OnDrawCalculatorButton (CDC* pDC, CRect rect, CBCGPToolbarButton* pButton, CBCGPVisualManager::BCGBUTTON_STATE state, int cmd /* CBCGPCalculator::CalculatorCommands */, CBCGPCalculator* pCalculator);
	virtual BOOL OnDrawCalculatorDisplay (CDC* pDC, CRect rect, const CString& strText, BOOL bMem, CBCGPCalculator* pCalculator);

	// Edit box:
	virtual BOOL OnDrawBrowseButton (CDC* pDC, CRect rect, CBCGPEdit* pEdit, CBCGPVisualManager::BCGBUTTON_STATE state, COLORREF& clrText);
	virtual void OnDrawEditClearButton(CDC* pDC, CBCGPButton* pButton, CRect rect);

	virtual COLORREF GetAutoHideButtonTextColor (CBCGPAutoHideButton* pButton);

	// Appbar window:
	virtual void OnDrawAppBarBorder (CDC* pDC, CBCGPAppBarWnd* pAppBarWnd,
									CRect rectBorder, CRect rectBorderSize);

	virtual void GetSmartDockingBaseMarkerColors (
		COLORREF& clrBaseGroupBackground,
		COLORREF& clrBaseGroupBorder);

	virtual COLORREF OnFillListBoxItem (CDC* pDC, CBCGPListBox* pListBox, int nItem, CRect rect, BOOL bIsHighlihted, BOOL bIsSelected);

	virtual COLORREF OnFillComboBoxItem(CDC* pDC, CBCGPComboBox* pComboBox, int nIndex, CRect rect, BOOL bIsHighlihted, BOOL bIsSelected);

	// Popup window:
#ifndef BCGP_EXCLUDE_POPUP_WINDOW
	virtual void OnDrawPopupWindowBorder (CDC* pDC, CRect rect);
	virtual COLORREF OnDrawPopupWindowCaption (CDC* pDC, CRect rectCaption, CBCGPPopupWindow* pPopupWnd);
	virtual void OnErasePopupWindowButton (CDC* pDC, CRect rectClient, CBCGPPopupWndButton* pButton);
	virtual void OnDrawPopupWindowButtonBorder (CDC* pDC, CRect rectClient, CBCGPPopupWndButton* pButton);
	virtual void OnFillPopupWindowBackground (CDC* pDC, CRect rect);
#endif

	// Day planner:
#ifndef BCGP_EXCLUDE_PLANNER
	virtual COLORREF OnFillPlannerCaption (CDC* pDC, CBCGPPlannerView* pView,
		CRect rect, BOOL bIsToday, BOOL bIsSelected, BOOL bNoBorder = FALSE, BOOL bHorz = TRUE);
	virtual void OnDrawPlannerTimeLine (CDC* pDC, CBCGPPlannerView* pView, CRect rect);
#endif // BCGP_EXCLUDE_PLANNER

	// Grid control:
#ifndef BCGP_EXCLUDE_GRID_CTRL
	virtual void OnDrawGridHeaderMenuButton (CBCGPGridCtrl* pCtrl, CDC* pDC, CRect rect,
		BOOL bHighlighted, BOOL bPressed, BOOL bDisabled);
	virtual BOOL OnSetGridColorTheme (CBCGPGridCtrl* pCtrl, BCGP_GRID_COLOR_DATA& theme);
#endif

	virtual void OnDrawDateTimeDropButton (CDC* pDC, CRect rect, BOOL bDisabled, BOOL bPressed, BOOL bHighlighted, CBCGPDateTimeCtrl* pCtrl);

	// Breadcrumb control:
	virtual void BreadcrumbDrawItem (CDC& dc, CBCGPBreadcrumb* pControl, BREADCRUMBITEMINFO* pItemInfo, CRect rectItem, UINT uState, COLORREF color);
	virtual void BreadcrumbDrawArrow (CDC& dc, CBCGPBreadcrumb* pControl, BREADCRUMBITEMINFO* pItemInfo, CRect rect, UINT uState, COLORREF color);
	virtual void BreadcrumbDrawLeftArrow (CDC& dc, CBCGPBreadcrumb* pControl, CRect rect, UINT uState, COLORREF color);
	virtual void BreadcrumbDrawItemBackground (CDC& dc, CBCGPBreadcrumb* pControl, BREADCRUMBITEMINFO* pItemInfo, CRect rectItem, UINT uState, COLORREF color);
	virtual void BreadcrumbDrawArrowBackground (CDC& dc, CBCGPBreadcrumb* pControl, BREADCRUMBITEMINFO* pItemInfo, CRect rectArrow, UINT uState, COLORREF color);
	virtual void BreadcrumbDrawLeftArrowBackground (CDC& dc, CBCGPBreadcrumb* pControl, CRect rect, UINT uState, COLORREF color);

#ifndef BCGP_EXCLUDE_RIBBON
	// Ribbon control:
	virtual COLORREF OnFillRibbonButton (
					CDC* pDC,
					CBCGPRibbonButton* pButton);

	virtual COLORREF OnFillRibbonPinnedButton (
					CDC* pDC,
					CBCGPRibbonButton* pButton, BOOL& bIsDarkPin);

	virtual void OnDrawRibbonButtonBorder (
					CDC* pDC,
					CBCGPRibbonButton* pButton);

	virtual void OnDrawRibbonPinnedButtonBorder (
					CDC* pDC,
					CBCGPRibbonButton* pButton);

	virtual void OnDrawRibbonCategoryScroll (
					CDC* pDC,
					CBCGPRibbonCategoryScroll* pScroll);

	virtual void OnDrawRibbonMenuCheckFrame (
					CDC* pDC,
					CBCGPRibbonButton* pButton,
					CRect rect);

	virtual void OnFillRibbonMenuFrame (
					CDC* pDC,
					CBCGPRibbonMainPanel* pPanel,
					CRect rect);

	virtual void OnDrawRibbonRecentFilesFrame (
					CDC* pDC,
					CBCGPRibbonMainPanel* pPanel,
					CRect rect);

	virtual COLORREF OnDrawRibbonStatusBarPane (CDC* pDC, CBCGPRibbonStatusBar* pBar,
					CBCGPRibbonStatusBarPane* pPane);

	virtual void GetRibbonSliderColors (CBCGPRibbonSlider* pSlider,
					BOOL bIsHighlighted,
					BOOL bIsPressed,
					BOOL bIsDisabled,
					COLORREF& clrLine,
					COLORREF& clrFill);
	virtual void OnDrawRibbonQATSeparator (CDC* pDC, CBCGPRibbonSeparator* pSeparator, CRect rect);

	virtual void OnDrawRibbonColorPaletteBox (CDC* pDC, CBCGPRibbonColorButton* pColorButton,
		CBCGPRibbonPaletteIcon* pIcon,
		COLORREF color, CRect rect, BOOL bDrawTopEdge, BOOL bDrawBottomEdge,
		BOOL bIsHighlighted, BOOL bIsChecked, BOOL bIsDisabled);

	virtual COLORREF OnDrawRibbonPanel (
					CDC* pDC,
					CBCGPRibbonPanel* pPanel,
					CRect rectPanel,
					CRect rectCaption);

#endif

	// Push button:
	virtual BOOL OnDrawPushButton (CDC* pDC, CRect rect, CBCGPButton* pButton, COLORREF& clrText);
	virtual BOOL IsDrawFocusRectOnPushButton(CBCGPButton* /*pButton*/) 	{ return FALSE; }

	CBrush		m_brGripperHorz;
	CBrush		m_brGripperVert;

	COLORREF	m_clrBarBkgnd;			// Control bar background color (expect menu bar)
	CBrush		m_brBarBkgnd;

	COLORREF	m_clrMenuRarelyUsed;
	CBrush		m_brMenuRarelyUsed;

	COLORREF	m_clrMenuLight;			// Color of the light menu area
	CBrush		m_brMenuLight;

	CBrush		m_brMenuConnect;

	COLORREF	m_clrInactiveTabText;
	CBrush		m_brTabBack;

	COLORREF	m_clrHighlight;			// Highlighted toolbar/menu item color
	CBrush		m_brHighlight;

	COLORREF	m_clrHighlightDn;		// Highlighted and pressed toolbar item color
	CBrush		m_brHighlightDn;

	COLORREF	m_clrHighlightChecked;
	CBrush		m_brHighlightChecked;
	COLORREF	m_clrPressedButtonBorder;	// Used in derived classes

	COLORREF	m_clrGripper;

	COLORREF	m_clrSeparator;
	CPen		m_penSeparator;

	COLORREF	m_clrPaneBorder;		// Status bar pane border

	COLORREF	m_clrMenuBorder;		// Menu border
	COLORREF	m_clrMenuItemBorder;	// Highlighted menu item border
	CPen		m_penMenuItemBorder;

	CBrush		m_brFloatToolBarBorder;	// Floating toolbar border

	BOOL		m_bConnectMenuToParent;

	BOOL		m_bShdowDroppedDownMenuButton;

	BOOL		m_bDrawLastTabLine;

	COLORREF	m_clrTaskPaneHotText;
	COLORREF	m_clrMenuSeparator;

	COLORREF	m_clrDockingBarScrollButton;
	COLORREF	m_clrDockingBarScrollButtonBorder;

	virtual void CreateGripperBrush ();
	virtual void ExtendMenuButton (CBCGPToolbarMenuButton* pMenuButton, CRect& rect);

	virtual COLORREF GetWindowColor () const;

	virtual CBrush& GetDlgButtonsAreaBrush(CWnd* pDlg, COLORREF* pclrLine = NULL);

	virtual void OnFillHighlightedArea (CDC* pDC, CRect rect, CBrush* pBrush,
		CBCGPToolbarButton* pButton);
};

#endif // !defined(AFX_BCGPVISUALMANAGERXP_H__062013FA_7440_4CEC_AA78_67893D195FFA__INCLUDED_)


The all-in-one toolbox for developers. https://bazinga.tools
You Are in Good Company
BAZINGA.TOOLS is the best all-in-one toolbox for all your needs…Bazinga!
—— Sheldon Lee Cooper
Your Privacy Is Guaranteed
Your data won’t leave your browser.
- ✅ No cookies
- ✅ No logging
- ✅ No IP fingerprinting
- ✅ No exception reports
- ✅ No popups
- ✅ Fully open source
First, install dependencies:
Second, run the development server:
npm run dev
Open http://localhost:3000 with your browser to see the result. The page auto-updates as you edit the file.
Add New Tools
All tools are located at
pages/. To add a new tool, just follow the convention of the exsiting tools. The tech stack is TypeScript + React + CSS Modules.
Your feedback and contributions are welcome!
- Add new tools
- Improve existing tools
- Support offline access
- Integrations (with Alfred, Raycast, Visual Studio Code…)


I'm about to submit my first scholarly manuscript to the top journal in my field, which has an acceptance rate of 20-25%. One of the co-authors on my paper, besides being generally well-known in this field, happens to be on the editorial board of this journal as an associate editor. Obviously I imagine that he'll automatically be excluded from the review process due to conflict of interest, but does their affiliation with the journal increase the chance of the paper getting accepted? I should note that the paper has already been through several rounds of internal revision and I've received excellent feedback so far from both this particular coauthor and others.
In principle, no.
In actuality? It likely does, under a couple of different mechanisms:
- An editor might be slightly more likely to give your paper the "benefit of the doubt" if its a borderline case between Revise/Reject, etc. This may also be true if your co-authors are "known" names, regardless of their editorial position.
- An AE at a journal likely has extensive experience writing for, and reviewing, papers in that journal. As such, they probably have a good sense what kind of papers they're looking for, the tone they should be written in, etc.
So the answer, in a practical sense, is likely "Yes, but not by a huge amount." And possibly not after controlling for recognition and experience.
All things considered, a paper coauthored by an editor should not improve the chances of getting accepted.
It is unlikely that the reviewers will be aware that one of the coauthors is an associate editor, so their reviews will be probably not be influenced by that. This is even more obvious in case the reviews are double-blind.
It is possible (although also unlikely) that the editor responsible for your paper might take a slightly more favorable view to your paper in case the reviews are borderline. However, in any case this will not improve your chances much.


This site offers Lessons, examples, and links on the C# programming language. The easiest way to open an XML file is to use a text editor, such as Notepad.
Open XML-Formate und -Dateinamenerweiterungen - Office-Support Die Open XML-Formate bieten zahlreiche Vorteile – nicht nur für Entwickler und die von Ihnen erbauten Lösungen, sondern auch für einzelne Personen und Organisationen aller Größen: Komprimierte Dateien Dateien werden automatisch komprimiert und sind in einigen Fällen bis zu 75 Prozent kleiner. 4 Ways to Open XML - wikiHow 26.07.2019 · Find the XML file you want to open. While you can use any basic text editor to open an XML file (see above), opening the file in a browser may make it a little easier to navigate. This is because most browsers automatically indent nested tags and allow you to collapse each section of the the XML tree. How to open and read XML file in C# , XmlReader , XmlTextReader
How to open and read XML file in C# , XmlReader , XmlTextReader How to open and read XML file in C# XML is a self describing language and it gives the data as well as the rules to extract what data it contains. Reading an XML file means that we are reading the information embedded in XML tags in an XML file. C# XML Parser. In the previous program we create an XML file and named it as products.xml. The Error: Failed to open xml file ' - GIANTS Software - Forum Dürfte trotzdem ganz einfach zu finden sein, weil du dann in der i3d höchstwahrscheinlich einen Files-Eintrag ohne Pfad finden wirst. Und die ID genau davon ist bei Open XML Formats and file name extensions - Office Support With the file open in your Office app, click File > Save as (or Save a copy, if the file is stored on OneDrive or SharePoint) and make sure the Save as type is set to the modern format. This will create a new copy of your file, in the Open XML format. What are the XML file name extensions? XML - Datei öffnen Download – kostenlos – CHIP
c# - XML Parsing - Read a Simple XML File and Retrieve Values - Stack Open Tasks.xml ; Load the first Task tag. In that task retrieve the values of the Name, Location and Arguments tags. Then open the RunWhen tag and retrieve the values of the Time and Date tags. After that open the Days tag and retrieve the value of each individual tag within. Retrieve the value of Enabled. What Is An XML File (And How Do I Open One)? If don't really need to edit XML files, but just need to view them on occasion, the browser you're using to read this article is well-suited to the job. And in fact, your default web browser is likely set up as the default viewer for XML files. So, double-clicking an XML file should open it in your browser. 4 Ways to Open XML - wikiHow Find the XML file you want to open. While you can use any basic text editor to open an XML file (see above), opening the file in a browser may make it a little easier to navigate. This is because most browsers automatically indent nested tags and allow you to collapse each section of the the XML tree. How to Open XML : Beginner Computer Tips - YouTube
To see an animation run, open it in an SVG animation capable browser or viewer, such as Opera (8+), Safari (4+), Chrome (2+), or Firefox (4+). Internet Explorer (9+) supports SVG, but not SMIL. Open Data Kit. 1,4 tis. To se mi líbí. Open Data Kit (ODK) is a free and open-source set of tools which help organizations author, field, and manage A C is a C/C++ Source Code file. Learn how to open a .C file or convert a C file to a different file format. How to open an Excel file from C# , How read the Excel cell values from C# program The Efficient XML Interchange Working Group is responsible for developing ways to exchange XML documents in ways that are as efficient as is practical without compromising the interoperability of XML itself.
Here's the same example using C# 3.0 features, including type wiki file var file = "ExportedWikiPages.xml"; // Open XML file


Yes, it is a fantastic solution - very easy to learn and use.
I am currently using it to make a web based scheduling system for a customer, and I am simply amazed at what it can do.
It doesn't do vector based animation or have a time line the way flash does. It also wont make stand alone .exe files, but it is great at everything else on your list - and the rate at which it is growing and improving is incredible.
I would highly recommend it.


Coyote Roller Guard: The Ultimate Solution for Coyote Deterrence
Residing in locations with a coyote population can pose a threat to the safety and security of your family pets and animals. These intelligent and agile animals are notorious for finding ways to breach fences and get in homes. If you’re seeking a reliable and efficient option to shield your residential or commercial property, then the Coyote Roller Guard is your response.
Prairie Wolf Roller Guard is a specifically designed and copyrighted system that protects against coyotes from gaining access to your home. The system consists of a collection of rotating rollers that can be attached to the top of existing fencings, walls, or gateways. This ingenious innovation creates a physical barrier that hinders prairie wolves from climbing up or jumping over fencings.
One of the main benefits of the Coyote Roller Guard is its simplicity and convenience of installment. You can conveniently attach the rollers to your existing fencing with some fundamental tools and equipment. The rollers are made of long lasting materials like aluminum or PVC, which ensures their longevity and effectiveness.
When a coyote attempts to scale the fence, the turning rollers spin, stopping the animal from getting a grip and creating it to lose its balance. This motion-based deterrent successfully stops coyotes from climbing over the fence and entering your residential property. It is a gentle strategy that does not trigger any kind of injury to the pets.
One more advantage of the Coyote Roller Guard is its versatility. It can be installed on different kinds of fencings, consisting of chain-link, wooden, or functioned iron fencings. Whether you have a residential property, a farm, or a commercial room, this system can give the security you require against prairie wolf intrusions.
Along with its main function of preventing coyotes from accessing your residential property, the Prairie wolf Roller Guard has various other benefits as well. It can additionally prevent various other animals, such as raccoons, opossums, and also thiefs. Its presence on your fence sends out a clear message that your residential or commercial property is safe and secure and off-limits to unwanted intruders.
In conclusion, if you’re encountering coyote-related problems and need a trustworthy remedy to secure your property, the Prairie wolf Roller Guard is a game-changer. Its straightforward installment, efficiency, and convenience make it a superb investment for both domestic and industrial homeowner. Do not let coyotes compromise the safety and security and wellness of your family pets or animals; mount the Prairie wolf Roller Guard and take pleasure in comfort.
Finding Ways To Keep Up With
The Best Advice About I’ve Ever Written


#pragma once

#include <string>
#include <iostream>

#include "cpp_properties/lexer.hpp"

std::string propertiesReadField(const std::string &propertiesFile, const std::string fieldName);


#ifndef _BIDL2SL_MATH_H_
#define _BIDL2SL_MATH_H_

#include <string>
#include <vector>
#include <set>
#include <map>
#include <bgcc.h>

namespace math {

    class Result {
    public:
        enum {
            E_SUCCESS = 0,
            E_OVERLOW = 1,
            E_DOWNLOW = 2
        };

        Result();
        Result(int32_t value);

        int32_t get_value() const;
        std::string get_desc() const;

        bool operator==(int32_t value) const;
        bool operator!=(int32_t value) const;
        bool operator< (int32_t value) const;
        bool operator!=(const Result& rhs) const;
        bool operator==(const Result& rhs) const;
        bool operator< (const Result& rhs) const;

    private:
        int32_t _value;

        static const struct desc_t {
            int32_t value;
            const char* desc;
        } descs[];
    };
    bool operator==(int32_t value, const Result&);
    bool operator!=(int32_t value, const Result&);
    bool operator< (int32_t value, const Result&);
    std::ostream& operator<<(std::ostream& o, const Result&);

    class Math : public bgcc::Shareable {
    public:
        virtual ~Math() { }

        virtual Result add(
            int32_t a,
            int32_t b,
            int32_t & sum,
            const std::map<std::string, std::string>& ctx) = 0;

    };

    class Math_add_args {
    public:
        Math_add_args();
        virtual ~Math_add_args();

        int32_t a;
        int32_t b;

        bool operator==(const Math_add_args& rhs) const;
        bool operator!=(const Math_add_args& rhs) const;
        bool operator< (const Math_add_args& rhs) const;
        int32_t read(char* request, int32_t request_len, bgcc::SharedPointer<bgcc::IProtocol> proto);
    };

    class Math_add_pargs {
    public:
        virtual ~Math_add_pargs();

        const int32_t* a;
        const int32_t* b;

        int32_t write(bgcc::SharedPointer<bgcc::IProtocol> proto) const;
    };

    class Math_add_result {
    public:
        Math_add_result();
        virtual ~Math_add_result();

        Result return_value;
        int32_t sum;

        bool operator==(const Math_add_result& rhs) const;
        bool operator!=(const Math_add_result& rhs) const;
        bool operator< (const Math_add_result& rhs) const;
        int32_t write(bgcc::SharedPointer<bgcc::IProtocol> proto) const;
    };

    class Math_add_presult {
    public:
        virtual ~Math_add_presult();

        Result* return_value;
        int32_t* sum;

        int32_t read(char *request, int32_t request_len, bgcc::SharedPointer<bgcc::IProtocol> proto) const;
    };

    class MathProxy : public bgcc::BaseProxy {
    public:
        MathProxy(
            bgcc::ServerInfo serverinfo,
            int32_t maxConn,
            bgcc::ServiceManager* mgr = NULL,
            int32_t tryCount = 5,
            int32_t tryInterval = 500);

        MathProxy(
            bgcc::ServerInfo serverinfo,
            bgcc::ServiceManager* mgr = NULL,
            int32_t tryCount = 5,
            int32_t tryInterval = 500);

        MathProxy(
            const std::string& proxy_name,
            int32_t tryCount = 5,
            int32_t tryInterval = 500);

        Result add(
            int32_t a,
            int32_t b,
            int32_t& sum,
            bool last = false);

    private:
        void send_add(
            const int32_t& a,
            const int32_t& b,
            int32_t seqid,
            bgcc::SharedPointer<bgcc::ConnInfo> conn);

        Result recv_add(
            int32_t& sum,
            bgcc::SharedPointer<bgcc::ConnInfo> conn);

    };

    class SSLMathProxy : public bgcc::SSLBaseProxy {
    public:
        SSLMathProxy(
            bgcc::ServerInfo serverinfo,
            int32_t maxConn,
            bgcc::ServiceManager* mgr = NULL,
            int32_t tryCount = 5,
            int32_t tryInterval = 500);

        SSLMathProxy(
            bgcc::ServerInfo serverinfo,
            bgcc::ServiceManager* mgr = NULL,
            int32_t tryCount = 5,
            int32_t tryInterval = 500);

        SSLMathProxy(
            const std::string& proxy_name,
            int32_t tryCount = 5,
            int32_t tryInterval = 500);

        Result add(
            int32_t a,
            int32_t b,
            int32_t& sum,
            bool last = false);

    private:
        void send_add(
            const int32_t& a,
            const int32_t& b,
            int32_t seqid,
            bgcc::SharedPointer<bgcc::ConnInfo> conn);

        Result recv_add(
            int32_t& sum,
            bgcc::SharedPointer<bgcc::ConnInfo> conn);

    };

    class MathProcessor : public bgcc::BaseProcessor {
    public:
        MathProcessor(bgcc::SharedPointer<Math> intf);

        virtual ~MathProcessor(){ }

        virtual int32_t process(
            char* request,
            int32_t request_len,
            bgcc::SharedPointer<bgcc::IProtocol> proto);

        virtual std::string get_name() const;

    protected:
        virtual int32_t do_function__(
            char* request,
            int32_t request_len,
            bgcc::SharedPointer<bgcc::IProtocol> proto,
            const std::string& fname, int32_t seqid);

        bgcc::SharedPointer<Math> __intf;

    private:
        int32_t do_add(
            char* request,
            int32_t request_len,
            bgcc::SharedPointer<bgcc::IProtocol> proto,
            int32_t seqid);

        typedef int32_t (MathProcessor::* do_function_ptr)(
            char* request,
            int32_t request_len,
            bgcc::SharedPointer<bgcc::IProtocol> proto,
            int32_t seqid);

        std::map<std::string, do_function_ptr> __fun_map;
    };
}

#endif


Does anyone have a complete list of port numbers? I have a firewall
where I am seeing traffic on port 161 but haven't been able to
track it down. All of the hosts behind the firewall are NT boxes
and I'm thinking that it's related to WINS. It seems that when I
do a Network browse it starts firing off packets to all IP addresses
on the other side of the firewall via udp port 161. It seems to start
at one IP and then increment bit wise.
I've found some web pages that list port numbers but they're pretty
much the same as unix:/etc/services.


This is an interactive problem.

Note: the XOR-sum of an array $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le 10^9$$$) is defined as $$$a_1 \oplus a_2 \oplus \ldots \oplus a_n$$$, where $$$\oplus$$$ denotes the bitwise XOR operation.

Little Dormi received an array of $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ for Christmas. However, while playing with it over the winter break, he accidentally dropped it into his XOR machine, and the array got lost.

The XOR machine is currently configured with a query size of $$$k$$$ (which you cannot change), and allows you to perform the following type of query: by giving the machine $$$k$$$ distinct indices $$$x_1, x_2, \ldots, x_k$$$, it will output $$$a_{x_1} \oplus a_{x_2} \oplus \ldots \oplus a_{x_k}$$$.

As Little Dormi's older brother, you would like to help him recover the XOR-sum of his array $$$a_1, a_2, \ldots, a_n$$$ by querying the XOR machine.

Little Dormi isn't very patient, so to be as fast as possible, you must query the XOR machine the minimum number of times to find the XOR-sum of his array. Formally, let $$$d$$$ be the minimum number of queries needed to find the XOR-sum of any array of length $$$n$$$ with a query size of $$$k$$$. Your program will be accepted if you find the correct XOR-sum in at most $$$d$$$ queries.

Lastly, you also noticed that with certain configurations of the machine $$$k$$$ and values of $$$n$$$, it may not be possible to recover the XOR-sum of Little Dormi's lost array. If that is the case, you should report it as well.

The array $$$a_1, a_2, \ldots, a_n$$$ is fixed before you start querying the XOR machine and does not change with the queries.


Best Order to Learn Front-End and Back-End Languages?
Hey guys I had a question. What is the best order to learn Front-End and Back-End Programming Languages. I’m looking to be a Web Developer and so far I’ve taught myself HTML, CSS, and I’m currently working on Bootstrap. I was looking into a coding bootcamp but I’ve read so many mixed reviews.


The beginning of a new year seems like a very good moment to start a "daily" challenge, so in order to give a concrete, measurable context to my plans for 2019 I decided to challenge myself to create a daily parametric design: a pattern, a texture, a full render or a basic idea, the only requirement is that each image is to be centered around a parametric/procedural design developed with Grasshopper.
As with all these challenges, the hardest part is to to be able to persevere and find consistency along an entire year - then again, if this was an easy task, it wouldn't be a challenge...
To start out I'm posting an image centered around the Christmas/New Year Holiday Theme - A shape that mixes the structure of snowflakes with the overall shape of a Christmas Tree.
The original idea was to have a full animation, however time and logistic constraints have made this not possible, so I'm just posting a still image.
The 3D model was created using a relatively simple Grasshopper definition, applied recursively for a small number of iterations.
The image was rendered in Blender using Cycles.
If you find the image interesting and want to know more about its creation please let me know, I might post a video showing the creation process.
And, by the way, Happy New Year!


(Very smart trapped Pug shown)
Are you stuck on a Proteomics, Metabolomics, or general Mass Spec related problem?
Could a few hours of help from someone whose favorite thing in this world is to read about and try to solve mass spec related questions maybe get you over that hump?
Can you handle some ridiculous levels of enthusiasm?
I do some consulting stuff sometimes. Contact me: (firstname.lastname@example.org)!


Your question of why...
Kenone, If I read your question right, it's likely because MS sells versions to a wide variety of customers, that want various levels of control over workstations. From local admin up to Domain manager (with multiple levels of support), there are a huge variety of requirements for IT managers to decide upon. The Wikileaks leaks, for example, could have likely been avoided with proper domain or forced local credentials. With a huge range of variety of customers, come a lot of decisions, and about what is possible. UNIX has had the same notion as Windows for way longer, most users have never had superuser level privs on UNIX boxes. The problem you state is that many software developers, never being forced to write an install for a non admin user, assumed that all installs would be done by admin level privs. It's really not Microsoft's 'fault'. But they created the earlier Windows environment (pre-Win2k) that allowed this behavior to flourish. Hope that helps!
Keep Up with TechRepublic


From our unique methodology to our ground-breaking projects, #MEET4IMPACT is always trying to push for innovation and experimentation within our sector. As we forge ahead on our journey, we keep learning...and we hope to take you along with us! That is why we have created our own set of resources to put our knowledge into helpful and creative
We hope this toolbox is as useful for you as it is for us - everything on here is available to download. Just follow the link at the bottom of the page.