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