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