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