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