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