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