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