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