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