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