<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="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