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