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