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