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