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