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