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