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