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