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