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