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