function base_fn(){
	clog("base_fn")
}
base_fn = {
	"a":"xyz"
}
function base_fn2(){
	clog("base_fn2")
}



rfns2 = {

	rfn_apply(){																													
		clog("RFN:apply")
return Reflect.apply(...arguments)
	},
	rfn_construct(){																				
		clog("RFN:construct")
return Reflect.construct(...arguments)
	},
	rfn_defineProperty(){																						
		clog("RFN:defineProperty")
return Reflect.defineProperty(...arguments)
	},
	rfn_deleteProperty(){																
		clog("RFN:deleteProperty")
return Reflect.deleteProperty(...arguments)
	},
	rfn_get(){																						
		clog("RFN:get")
return Reflect.get(...arguments)
	},
	rfn_getOwnPropertyDescriptor(){																	
		clog("RFN:getOwnPropertyDescriptor")
return Reflect.getOwnPropertyDescriptor(...arguments)
	},
	rfn_getPrototypeOf(){																
		clog("RFN:getPrototypeOf")
return Reflect.getPrototypeOf(...arguments)
	},
	rfn_has(){																							
		clog("RFN:has")
return Reflect.has(...arguments)
	},
	rfn_isExtensible(){																					
		clog("RFN:isExtensible")
return Reflect.isExtensible(...arguments)
	},
	rfn_ownKeys(){																				
		clog("RFN:ownKeys")
return Reflect.ownKeys(...arguments)
	},
	rfn_preventExtensions(){																		
		clog("RFN:preventExtensions")
return Reflect.preventExtensions(...arguments)
	},
	rfn_set(){																					
		clog("RFN:set")
return Reflect.set(...arguments)
	},
	rfn_setPrototypeOf(){																						
		clog("RFN:setPrototypeOf")
return Reflect.setPrototypeOf(...arguments)
	},

}



rprox2 = {
apply: rfns.rfn_apply,
construct: rfns.rfn_construct,
defineProperty: rfns.rfn_defineProperty,
deleteProperty: rfns.rfn_deleteProperty,
get: rfns.rfn_get,
getOwnPropertyDescriptor: rfns.rfn_getOwnPropertyDescriptor,
getPrototypeOf: rfns.rfn_getPrototypeOf,
has: rfns.rfn_has,
isExtensible: rfns.rfn_isExtensible,
ownKeys: rfns.rfn_ownKeys,
preventExtensions: rfns.rfn_preventExtensions,
set: rfns.rfn_set,
setPrototypeOf: rfns.rfn_setPrototypeOf,
}




// dec_fn = new Proxy(base_fn,rprox2)

// base_fn.__proto__
base_fn.__proto__ = new Proxy(base_fn.__proto__,rprox2)

// base_fn.prototype = new Proxy(base_fn.prototype,rprox2)



base_fn.q=3
base_fn.q={}