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