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