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