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