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