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