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