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