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