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