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